Upload PromptForge v1.0 — Structured prompt generator for Google AI Studio

.env.example

@@ -0,0 +1,16 @@
+# PromptForge — Environment Variables
+# Copy this file to .env and fill in your values.
+# NEVER commit .env to version control.
+
+# ── Google AI Studio / Gemini ──────────────────────────────────────
+# Get your key at: https://aistudio.google.com/app/apikey
+GOOGLE_API_KEY=your_google_api_key_here
+
+# ── Hugging Face Inference API ─────────────────────────────────────
+# Get your key at: https://huggingface.co/settings/tokens
+HF_API_KEY=your_huggingface_api_key_here
+
+# ── Server settings ────────────────────────────────────────────────
+HOST=0.0.0.0
+PORT=8000
+LOG_DIR=./logs

.gitignore

@@ -0,0 +1,12 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+logs/
+*.egg-info/
+dist/
+.venv/
+venv/
+node_modules/
+.DS_Store

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.11-slim
+
+LABEL maintainer="PromptForge"
+LABEL description="Structured prompt generator for Google AI Studio"
+
+# System deps
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python deps
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY backend/ ./backend/
+COPY frontend/ ./frontend/
+
+# Logs directory
+RUN mkdir -p logs
+
+WORKDIR /app/backend
+
+# Environment defaults (override in your deployment / .env)
+ENV HOST=0.0.0.0
+ENV PORT=8000
+ENV LOG_DIR=/app/logs
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \
+  CMD curl -f http://localhost:8000/health || exit 1
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,10 +1,254 @@
+# ⚙️ PromptForge
+
+**PromptForge** is a cloud-ready FastAPI service that converts raw user instructions into
+**structured, ready-to-use prompts** for Google AI Studio. It follows a 5-step guided workflow
+with a clean HTML/JS frontend, optional AI enhancement via Google Gemini or Hugging Face, and
+persistent prompt history.
+
+---
+
+## 📁 Folder Structure
+
+```
+promptforge/
+├── backend/
+│   ├── main.py            ← FastAPI server + all routes
+│   ├── schemas.py         ← Pydantic request/response models
+│   ├── prompt_logic.py    ← Core instruction → structured prompt engine
+│   ├── ai_client.py       ← Hugging Face & Google Gemini integration
+│   ├── store.py           ← In-memory store with JSON persistence
+│   ├── requirements.txt
+│   └── tests/
+│       └── test_promptforge.py
+├── frontend/
+│   ├── index.html         ← Single-page UI
+│   ├── client.js          ← Fetch-based API client
+│   └── style.css          ← Dark-mode responsive styling
+├── logs/                  ← Auto-created; stores prompt_history.json
+├── Dockerfile
+├── docker-compose.yml
+├── .env.example           ← Copy to .env and fill API keys
+├── .gitignore
+└── README.md
+```
+
+---
+
+## 🔄 5-Step Workflow
+
+| Step | Endpoint | Description |
+|------|----------|-------------|
+| **0** | `POST /api/generate` | Accept raw instruction → produce JSON manifest |
+| **1** | *(frontend)* | Display manifest for human review |
+| **2** | `POST /api/approve` | Approve (with optional edits) → finalize prompt |
+| **3** | *(frontend)* | Preview plain-text + JSON output |
+| **4** | `POST /api/export` | Download as `.json` or `.txt` |
+| **5** | `POST /api/refine` | Iterate with feedback → new manifest version |
+
+---
+
+## 🚀 Running Locally
+
+### 1. Clone & set up environment
+
+```bash
+git clone <your-repo-url>
+cd promptforge
+
+# Create virtual environment
+python -m venv .venv
+source .venv/bin/activate          # Windows: .venv\Scripts\activate
+
+# Install dependencies
+pip install -r backend/requirements.txt
+```
+
+### 2. Configure API keys
+
+```bash
+cp .env.example .env
+# Open .env and fill in your keys:
+#   GOOGLE_API_KEY=...
+#   HF_API_KEY=...
+```
+
+> **Security note:** API keys entered in the frontend are sent only over HTTPS
+> and are never logged or stored. Keys in `.env` are for server-side defaults;
+> frontend keys override them per-request.
+
+### 3. Start the server
+
+```bash
+cd backend
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+Open **http://localhost:8000** in your browser.  
+API docs: **http://localhost:8000/docs**
+
+---
+
+## 🐳 Docker Deployment
+
+```bash
+# Build and run
+docker-compose up --build
+
+# Or production detached
+docker-compose up -d
+```
+
+---
+
+## ☁️ Cloud Deployment (Google Cloud Run)
+
+```bash
+# Build container
+gcloud builds submit --tag gcr.io/YOUR_PROJECT/promptforge
+
+# Deploy
+gcloud run deploy promptforge \
+  --image gcr.io/YOUR_PROJECT/promptforge \
+  --platform managed \
+  --region us-central1 \
+  --allow-unauthenticated \
+  --set-env-vars "LOG_DIR=/tmp/logs"
+```
+
+For Cloud Run, set secrets via Secret Manager:
+
+```bash
+gcloud secrets create GOOGLE_API_KEY --data-file=- <<< "your-key"
+gcloud secrets create HF_API_KEY --data-file=- <<< "your-key"
+```
+
+---
+
+## 🧪 Running Tests
+
+```bash
+cd backend
+pytest tests/ -v
+```
+
+Expected output: **19 tests passing**.
+
 ---
-title: Promptforge
-emoji: 🏃
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
+
+## 📡 API Reference
+
+### `POST /api/generate`
+
+```json
+{
+  "instruction": "Generate a TypeScript React component with TailwindCSS and unit tests.",
+  "output_format": "both",
+  "provider": "google",
+  "api_key": "YOUR_KEY_HERE",
+  "enhance": true,
+  "extra_context": "Must support dark mode and be accessible."
+}
+```
+
+**Response:** `GenerateResponse` with full `PromptManifest`.
+
+---
+
+### `POST /api/approve`
+
+```json
+{
+  "prompt_id": "<uuid>",
+  "edits": {
+    "role": "Principal Software Engineer",
+    "constraints": ["Use TypeScript strict mode.", "Tests must use Vitest."]
+  }
+}
+```
+
+---
+
+### `POST /api/export`
+
+```json
+{ "prompt_id": "<uuid>", "export_format": "json" }
+```
+
+---
+
+### `POST /api/refine`
+
+```json
+{
+  "prompt_id": "<uuid>",
+  "feedback": "Add ARIA labels and keyboard navigation support.",
+  "provider": "none"
+}
+```
+
+---
+
+### `GET /api/history`
+
+Returns all previously generated prompts with status and version info.
+
+---
+
+## 🏗️ Example: Full Prompt Output
+
+**Instruction:** `"Generate a TypeScript React component with TailwindCSS and unit tests."`
+
+```
+## ROLE
+You are a Senior Frontend Engineer.
+
+## TASK
+Generate a TypeScript React component with TailwindCSS and unit tests.
+
+## INPUT FORMAT
+A plain-text string describing the user's request or the content to process.
+
+## OUTPUT FORMAT
+Source code inside a properly labeled fenced code block. Include a brief
+explanation before and after the block.
+
+## CONSTRAINTS
+1. Use TypeScript with strict mode enabled.
+2. Use TailwindCSS utility classes exclusively; avoid custom CSS unless unavoidable.
+3. Include comprehensive unit tests with >80% coverage.
+
+## STYLE & TONE
+Professional and clear; balance technical accuracy with readability.
+
+## SAFETY GUIDELINES
+1. Do not produce harmful, misleading, or unethical content.
+2. Respect intellectual property; do not reproduce copyrighted material verbatim.
+3. If the request is ambiguous or potentially harmful, ask for clarification.
+4. Adhere to Google AI Studio usage policies and Responsible AI guidelines.
+
+## FEW-SHOT EXAMPLES
+**Input:** Create a Button component.
+**Output:** ```tsx
+interface ButtonProps { label: string; onClick: () => void; }
+export const Button = ({ label, onClick }: ButtonProps) => (
+  <button onClick={onClick} className='px-4 py-2 bg-blue-600 text-white rounded'>{label}</button>
+);
+```
+
+---
+*Prompt generated by PromptForge — compatible with Google AI Studio.*
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🔐 Security Notes
+
+- API keys are accepted per-request and **never persisted** in logs or storage.
+- The `store.py` logs contain instruction text and prompt content but strip API keys.
+- For production: add authentication (e.g., FastAPI `Depends` with Bearer tokens), enforce HTTPS, and set `allow_origins` in CORS middleware to your domain only.
+
+---
+
+## 📝 License
+
+MIT — use freely, modify as needed.

backend/ai_client.py

@@ -0,0 +1,137 @@
+"""
+PromptForge — AI client interface.
+Supports optional enhancement via:
+  - Hugging Face Inference API (text-generation models)
+  - Google AI Studio / Gemini API (generateContent)
+"""
+from __future__ import annotations
+import logging
+from typing import Optional
+
+import httpx
+
+logger = logging.getLogger("promptforge.ai_client")
+
+# ---------------------------------------------------------------------------
+# Hugging Face
+# ---------------------------------------------------------------------------
+
+HF_API_BASE = "https://api-inference.huggingface.co/models"
+HF_DEFAULT_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
+
+
+async def enhance_with_huggingface(
+    raw_prompt: str,
+    api_key: str,
+    model: str = HF_DEFAULT_MODEL,
+    max_new_tokens: int = 512,
+) -> str:
+    """
+    Call the Hugging Face Inference API to enhance a raw prompt text.
+    Returns the enhanced prompt string, or the original on failure.
+    """
+    system_instruction = (
+        "You are an expert prompt engineer specializing in Google AI Studio prompts. "
+        "Given a draft prompt, improve its clarity, specificity, and structure. "
+        "Return ONLY the improved prompt text — no commentary."
+    )
+    payload = {
+        "inputs": f"<s>[INST] {system_instruction}\n\nDRAFT PROMPT:\n{raw_prompt}\n\nIMPROVED PROMPT: [/INST]",
+        "parameters": {"max_new_tokens": max_new_tokens, "return_full_text": False},
+    }
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{HF_API_BASE}/{model}"
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(url, json=payload, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+            # HF returns a list of dicts with "generated_text"
+            if isinstance(data, list) and data:
+                return data[0].get("generated_text", raw_prompt).strip()
+            return raw_prompt
+    except Exception as exc:
+        logger.warning("HuggingFace enhancement failed: %s", exc)
+        return raw_prompt
+
+
+# ---------------------------------------------------------------------------
+# Google AI Studio / Gemini
+# ---------------------------------------------------------------------------
+
+GOOGLE_AI_BASE = "https://generativelanguage.googleapis.com/v1beta"
+GOOGLE_DEFAULT_MODEL = "gemini-1.5-flash"
+
+
+async def enhance_with_google(
+    raw_prompt: str,
+    api_key: str,
+    model: str = GOOGLE_DEFAULT_MODEL,
+) -> str:
+    """
+    Call the Google Generative Language API (Gemini) to enhance a prompt.
+    Returns the enhanced prompt string, or the original on failure.
+    """
+    url = f"{GOOGLE_AI_BASE}/models/{model}:generateContent?key={api_key}"
+    system_part = (
+        "You are an expert prompt engineer. "
+        "Improve the following draft prompt for use in Google AI Studio. "
+        "Return ONLY the improved prompt — no preamble or commentary."
+    )
+    payload = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": f"{system_part}\n\nDRAFT PROMPT:\n{raw_prompt}"}
+                ]
+            }
+        ],
+        "generationConfig": {"maxOutputTokens": 1024, "temperature": 0.4},
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(url, json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+            candidates = data.get("candidates", [])
+            if candidates:
+                parts = candidates[0].get("content", {}).get("parts", [])
+                if parts:
+                    return parts[0].get("text", raw_prompt).strip()
+            return raw_prompt
+    except Exception as exc:
+        logger.warning("Google AI enhancement failed: %s", exc)
+        return raw_prompt
+
+
+# ---------------------------------------------------------------------------
+# Dispatcher
+# ---------------------------------------------------------------------------
+
+async def enhance_prompt(
+    raw_prompt: str,
+    provider: str,
+    api_key: Optional[str],
+) -> tuple[str, str]:
+    """
+    Dispatch enhancement to the correct provider.
+    Returns (enhanced_text, notes_string).
+    """
+    if not api_key:
+        return raw_prompt, "No API key provided — skipping AI enhancement."
+
+    if provider == "huggingface":
+        enhanced = await enhance_with_huggingface(raw_prompt, api_key)
+        notes = f"Enhanced via Hugging Face ({HF_DEFAULT_MODEL})."
+    elif provider == "google":
+        enhanced = await enhance_with_google(raw_prompt, api_key)
+        notes = f"Enhanced via Google Gemini ({GOOGLE_DEFAULT_MODEL})."
+    else:
+        return raw_prompt, "Provider 'none' selected — no enhancement applied."
+
+    if enhanced == raw_prompt:
+        notes += " (Enhancement returned unchanged text — possible API issue.)"
+
+    return enhanced, notes

backend/main.py

@@ -0,0 +1,264 @@
+"""
+PromptForge — FastAPI server
+Run: uvicorn main:app --reload --host 0.0.0.0 --port 8000
+"""
+from __future__ import annotations
+import logging
+import os
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+import store
+from ai_client import enhance_prompt
+from prompt_logic import apply_edits, build_manifest, refine_with_feedback
+from schemas import (
+    ApproveRequest,
+    ApproveResponse,
+    ExportRequest,
+    ExportResponse,
+    GenerateRequest,
+    GenerateResponse,
+    HistoryResponse,
+    RefineRequest,
+)
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+)
+logger = logging.getLogger("promptforge.main")
+
+# ---------------------------------------------------------------------------
+# App bootstrap
+# ---------------------------------------------------------------------------
+app = FastAPI(
+    title="PromptForge",
+    description="Autonomously generate structured, ready-to-use prompts for Google AI Studio.",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],   # Lock this down in production
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Serve frontend from /frontend directory
+_FRONTEND_DIR = Path(__file__).parent.parent / "frontend"
+if _FRONTEND_DIR.exists():
+    app.mount("/static", StaticFiles(directory=str(_FRONTEND_DIR)), name="static")
+
+
+@app.on_event("startup")
+async def _startup() -> None:
+    store.load_from_disk()
+    logger.info("PromptForge started. Visit http://localhost:8000")
+
+
+# ---------------------------------------------------------------------------
+# Root — serve the HTML frontend
+# ---------------------------------------------------------------------------
+
+@app.get("/", response_class=HTMLResponse, tags=["Frontend"])
+async def serve_frontend() -> HTMLResponse:
+    index = _FRONTEND_DIR / "index.html"
+    if index.exists():
+        return HTMLResponse(content=index.read_text(), status_code=200)
+    return HTMLResponse(
+        content="<h1>PromptForge API is running.</h1><p>Visit <a href='/docs'>/docs</a> for API reference.</p>",
+        status_code=200,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Step 0 + 1: Accept instruction → return manifest
+# ---------------------------------------------------------------------------
+
+@app.post("/api/generate", response_model=GenerateResponse, tags=["Prompts"])
+async def generate_prompt(req: GenerateRequest) -> GenerateResponse:
+    """
+    **Step 1** — Accept a raw user instruction and return a JSON manifest
+    of the proposed structured prompt. The manifest must be approved before
+    the prompt is finalized.
+    """
+    logger.info("GENERATE | instruction=%r | enhance=%s | provider=%s",
+                req.instruction[:80], req.enhance, req.provider)
+
+    manifest = build_manifest(
+        instruction=req.instruction,
+        extra_context=req.extra_context,
+    )
+
+    # Optional AI enhancement pass
+    if req.enhance and req.provider != "none":
+        enhanced_text, notes = await enhance_prompt(
+            raw_prompt=manifest.structured_prompt.raw_prompt_text,
+            provider=req.provider,
+            api_key=req.api_key,
+        )
+        # Patch the raw_prompt_text with the enhanced version
+        sp = manifest.structured_prompt.model_copy(
+            update={"raw_prompt_text": enhanced_text}
+        )
+        manifest = manifest.model_copy(
+            update={"structured_prompt": sp, "enhancement_notes": notes}
+        )
+        logger.info("ENHANCE | %s", notes)
+
+    store.save(manifest)
+    logger.info("SAVED   | prompt_id=%s version=%d", manifest.prompt_id, manifest.version)
+
+    return GenerateResponse(
+        success=True,
+        prompt_id=manifest.prompt_id,
+        manifest=manifest,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Step 2 + 3: Human approval
+# ---------------------------------------------------------------------------
+
+@app.post("/api/approve", response_model=ApproveResponse, tags=["Prompts"])
+async def approve_prompt(req: ApproveRequest) -> ApproveResponse:
+    """
+    **Step 2/3** — Approve (and optionally edit) a pending manifest.
+    Returns the finalized structured prompt ready for Google AI Studio.
+    """
+    manifest = store.get(req.prompt_id)
+    if not manifest:
+        raise HTTPException(status_code=404, detail=f"Prompt '{req.prompt_id}' not found.")
+
+    if req.edits:
+        manifest = apply_edits(manifest, req.edits)
+    else:
+        manifest = manifest.model_copy(update={"status": "approved"})
+
+    store.save(manifest)
+    logger.info("APPROVED | prompt_id=%s", manifest.prompt_id)
+
+    return ApproveResponse(
+        success=True,
+        prompt_id=manifest.prompt_id,
+        message="Prompt approved and finalized.",
+        finalized_prompt=manifest.structured_prompt,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Step 4: Export
+# ---------------------------------------------------------------------------
+
+@app.post("/api/export", response_model=ExportResponse, tags=["Prompts"])
+async def export_prompt(req: ExportRequest) -> ExportResponse:
+    """
+    **Step 4** — Export a finalized prompt as JSON or plain text.
+    """
+    manifest = store.get(req.prompt_id)
+    if not manifest:
+        raise HTTPException(status_code=404, detail=f"Prompt '{req.prompt_id}' not found.")
+    if manifest.status not in ("approved", "exported"):
+        raise HTTPException(
+            status_code=400,
+            detail="Prompt must be approved before exporting. Call /api/approve first.",
+        )
+
+    manifest = manifest.model_copy(update={"status": "exported"})
+    store.save(manifest)
+    logger.info("EXPORTED | prompt_id=%s format=%s", manifest.prompt_id, req.export_format)
+
+    if req.export_format == "text":
+        data = manifest.structured_prompt.raw_prompt_text
+    elif req.export_format == "json":
+        data = manifest.structured_prompt.model_dump()
+    else:  # both
+        data = {
+            "json": manifest.structured_prompt.model_dump(),
+            "text": manifest.structured_prompt.raw_prompt_text,
+        }
+
+    return ExportResponse(success=True, prompt_id=manifest.prompt_id, data=data)
+
+
+# ---------------------------------------------------------------------------
+# Step 5: Iterative refinement
+# ---------------------------------------------------------------------------
+
+@app.post("/api/refine", response_model=GenerateResponse, tags=["Prompts"])
+async def refine_prompt(req: RefineRequest) -> GenerateResponse:
+    """
+    **Step 5** — Refine an existing prompt with user feedback.
+    Creates a new version (v+1) of the manifest.
+    """
+    manifest = store.get(req.prompt_id)
+    if not manifest:
+        raise HTTPException(status_code=404, detail=f"Prompt '{req.prompt_id}' not found.")
+
+    refined = refine_with_feedback(manifest, req.feedback)
+
+    if req.provider != "none" and req.api_key:
+        enhanced_text, notes = await enhance_prompt(
+            raw_prompt=refined.structured_prompt.raw_prompt_text,
+            provider=req.provider,
+            api_key=req.api_key,
+        )
+        sp = refined.structured_prompt.model_copy(update={"raw_prompt_text": enhanced_text})
+        refined = refined.model_copy(update={"structured_prompt": sp, "enhancement_notes": notes})
+
+    store.save(refined)
+    logger.info("REFINED  | prompt_id=%s new_version=%d", refined.prompt_id, refined.version)
+
+    return GenerateResponse(
+        success=True,
+        prompt_id=refined.prompt_id,
+        manifest=refined,
+        message=f"Refined to v{refined.version} — awaiting approval.",
+    )
+
+
+# ---------------------------------------------------------------------------
+# History
+# ---------------------------------------------------------------------------
+
+@app.get("/api/history", response_model=HistoryResponse, tags=["History"])
+async def get_history() -> HistoryResponse:
+    """Return a list of all previously generated prompts."""
+    entries = store.all_entries()
+    return HistoryResponse(total=len(entries), entries=entries)
+
+
+@app.get("/api/history/{prompt_id}", tags=["History"])
+async def get_prompt(prompt_id: str) -> dict:
+    """Return the full manifest for a single prompt by ID."""
+    manifest = store.get(prompt_id)
+    if not manifest:
+        raise HTTPException(status_code=404, detail=f"Prompt '{prompt_id}' not found.")
+    return manifest.model_dump(mode="json")
+
+
+@app.delete("/api/history/{prompt_id}", tags=["History"])
+async def delete_prompt(prompt_id: str) -> JSONResponse:
+    """Delete a prompt from history."""
+    deleted = store.delete(prompt_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail=f"Prompt '{prompt_id}' not found.")
+    return JSONResponse({"success": True, "message": f"Prompt {prompt_id} deleted."})
+
+
+# ---------------------------------------------------------------------------
+# Health
+# ---------------------------------------------------------------------------
+
+@app.get("/health", tags=["System"])
+async def health() -> dict:
+    return {"status": "ok", "service": "PromptForge", "version": "1.0.0"}

backend/prompt_logic.py

@@ -0,0 +1,264 @@
+"""
+PromptForge — Core logic to transform raw user instructions into structured prompts
+compatible with Google AI Studio.
+"""
+from __future__ import annotations
+import re
+import uuid
+import textwrap
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from schemas import PromptManifest, StructuredPrompt
+
+
+# ---------------------------------------------------------------------------
+# Heuristic keyword maps used for lightweight classification
+# ---------------------------------------------------------------------------
+
+_ROLE_MAP: List[tuple[List[str], str]] = [
+    (["react", "vue", "angular", "component", "frontend", "ui", "tailwind"], "Senior Frontend Engineer"),
+    (["api", "rest", "fastapi", "flask", "django", "backend", "endpoint"], "Senior Backend Engineer"),
+    (["sql", "database", "postgres", "mongo", "query", "schema"], "Database Architect"),
+    (["test", "unittest", "pytest", "jest", "coverage", "tdd"], "QA / Test Automation Engineer"),
+    (["devops", "docker", "kubernetes", "ci/cd", "deploy", "cloud", "terraform"], "DevOps / Cloud Engineer"),
+    (["machine learning", "ml", "model", "training", "dataset", "neural", "pytorch", "tensorflow"], "Machine Learning Engineer"),
+    (["data analysis", "pandas", "numpy", "visualization", "chart", "plot"], "Data Scientist"),
+    (["security", "auth", "oauth", "jwt", "encrypt", "pentest"], "Security Engineer"),
+    (["write", "blog", "article", "essay", "copy", "content"], "Professional Content Writer"),
+    (["summarize", "summary", "tldr", "abstract"], "Technical Summarizer"),
+    (["translate", "localize", "language"], "Multilingual Translation Specialist"),
+]
+
+_STYLE_MAP: List[tuple[List[str], str]] = [
+    (["simple", "beginner", "basic", "easy", "novice"], "Clear, simple language; avoid jargon; explain every step."),
+    (["expert", "advanced", "senior", "professional"], "Concise, technically precise; assume expert knowledge."),
+    (["formal", "report", "documentation", "spec"], "Formal prose; structured headings; professional tone."),
+    (["creative", "story", "narrative", "fiction"], "Engaging, vivid language; narrative structure."),
+]
+
+_SAFETY_DEFAULTS: List[str] = [
+    "Do not produce harmful, misleading, or unethical content.",
+    "Respect intellectual property; do not reproduce copyrighted material verbatim.",
+    "If the request is ambiguous or potentially harmful, ask for clarification rather than guessing.",
+    "Adhere to Google AI Studio usage policies and Responsible AI guidelines.",
+]
+
+_CONSTRAINT_PATTERNS: List[tuple[str, str]] = [
+    (r"\btypescript\b", "Use TypeScript with strict mode enabled."),
+    (r"\bpython\b", "Use Python 3.10+; follow PEP-8 style guide."),
+    (r"\btailwind\b", "Use TailwindCSS utility classes exclusively; avoid custom CSS unless unavoidable."),
+    (r"\bunit test[s]?\b|\bjest\b|\bpytest\b", "Include comprehensive unit tests with >80% coverage."),
+    (r"\bjson\b", "All structured data must be valid, parseable JSON."),
+    (r"\baccessib\w+\b", "Ensure WCAG 2.1 AA accessibility compliance."),
+    (r"\bresponsive\b", "Design must be fully responsive for mobile, tablet, and desktop."),
+    (r"\bdocker\b", "Provide a Dockerfile and docker-compose.yml."),
+    (r"\bno comment[s]?\b", "Do not include inline code comments."),
+    (r"\bcomment[s]?\b", "Include clear, concise inline comments explaining non-obvious logic."),
+]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def build_manifest(
+    instruction: str,
+    extra_context: Optional[str] = None,
+    version: int = 1,
+    existing_id: Optional[str] = None,
+) -> PromptManifest:
+    """Transform a raw instruction string into a full PromptManifest."""
+    prompt_id = existing_id or str(uuid.uuid4())
+    lower = instruction.lower()
+
+    role = _infer_role(lower)
+    task = _infer_task(instruction)
+    input_fmt = _infer_input_format(lower)
+    output_fmt = _infer_output_format(lower)
+    constraints = _infer_constraints(lower)
+    style = _infer_style(lower)
+    safety = list(_SAFETY_DEFAULTS)
+    examples = _build_examples(lower, role)
+
+    raw_text = _render_raw_prompt(
+        role=role,
+        task=task,
+        input_fmt=input_fmt,
+        output_fmt=output_fmt,
+        constraints=constraints,
+        style=style,
+        safety=safety,
+        examples=examples,
+        extra_context=extra_context,
+    )
+
+    structured = StructuredPrompt(
+        role=role,
+        task=task,
+        input_format=input_fmt,
+        output_format=output_fmt,
+        constraints=constraints,
+        style=style,
+        safety=safety,
+        examples=examples,
+        raw_prompt_text=raw_text,
+    )
+
+    return PromptManifest(
+        prompt_id=prompt_id,
+        version=version,
+        created_at=datetime.utcnow(),
+        instruction=instruction,
+        status="pending",
+        structured_prompt=structured,
+    )
+
+
+def apply_edits(manifest: PromptManifest, edits: Dict[str, Any]) -> PromptManifest:
+    """Apply user edits to an existing manifest and regenerate raw text."""
+    sp = manifest.structured_prompt.model_copy(update=edits)
+    sp = sp.model_copy(
+        update={
+            "raw_prompt_text": _render_raw_prompt(
+                role=sp.role,
+                task=sp.task,
+                input_fmt=sp.input_format,
+                output_fmt=sp.output_format,
+                constraints=sp.constraints,
+                style=sp.style,
+                safety=sp.safety,
+                examples=sp.examples,
+            )
+        }
+    )
+    return manifest.model_copy(
+        update={"structured_prompt": sp, "status": "approved"}
+    )
+
+
+def refine_with_feedback(manifest: PromptManifest, feedback: str) -> PromptManifest:
+    """Naively incorporate textual feedback into the task description (pre-AI fallback)."""
+    new_task = manifest.structured_prompt.task + f"\n\nAdditional requirements from user feedback:\n{feedback}"
+    return build_manifest(
+        instruction=manifest.instruction + " " + feedback,
+        version=manifest.version + 1,
+        existing_id=manifest.prompt_id,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Private helpers
+# ---------------------------------------------------------------------------
+
+def _infer_role(lower: str) -> str:
+    for keywords, role in _ROLE_MAP:
+        if any(kw in lower for kw in keywords):
+            return role
+    return "General AI Assistant"
+
+
+def _infer_task(instruction: str) -> str:
+    # Sentence-case the instruction and ensure it ends with a period
+    task = instruction.strip()
+    if not task.endswith((".", "!", "?")):
+        task += "."
+    return task
+
+
+def _infer_input_format(lower: str) -> str:
+    if any(k in lower for k in ["json", "object", "dict"]):
+        return "A JSON object containing the relevant fields described in the task."
+    if any(k in lower for k in ["file", "upload", "csv", "pdf"]):
+        return "A file upload (the file path or base64-encoded content will be provided)."
+    if any(k in lower for k in ["image", "photo", "screenshot", "diagram"]):
+        return "An image or screenshot provided as a URL or base64 string."
+    return "A plain-text string describing the user's request or the content to process."
+
+
+def _infer_output_format(lower: str) -> str:
+    if any(k in lower for k in ["json", "structured", "object"]):
+        return "A well-formatted JSON object with clearly named keys. Include no extra prose outside the JSON block."
+    if any(k in lower for k in ["markdown", "md", "readme", "documentation"]):
+        return "A Markdown-formatted document with appropriate headers, code blocks, and lists."
+    if any(k in lower for k in ["code", "script", "function", "class", "component"]):
+        return "Source code inside a properly labeled fenced code block (e.g., ```typescript ... ```). Include a brief explanation before and after the block."
+    if any(k in lower for k in ["list", "bullet", "steps"]):
+        return "A numbered or bulleted list with concise, actionable items."
+    return "A clear, well-structured plain-text response."
+
+
+def _infer_constraints(lower: str) -> List[str]:
+    found: List[str] = []
+    for pattern, constraint in _CONSTRAINT_PATTERNS:
+        if re.search(pattern, lower):
+            found.append(constraint)
+    if not found:
+        found.append("Keep the response concise and directly relevant to the task.")
+    return found
+
+
+def _infer_style(lower: str) -> str:
+    for keywords, style in _STYLE_MAP:
+        if any(kw in lower for kw in keywords):
+            return style
+    return "Professional and clear; balance technical accuracy with readability."
+
+
+def _build_examples(lower: str, role: str) -> Optional[List[Dict[str, str]]]:
+    """Return 1 few-shot example where applicable."""
+    if "react" in lower or "component" in lower:
+        return [
+            {
+                "input": "Create a Button component.",
+                "output": "```tsx\ninterface ButtonProps { label: string; onClick: () => void; }\nexport const Button = ({ label, onClick }: ButtonProps) => (\n  <button onClick={onClick} className='px-4 py-2 bg-blue-600 text-white rounded'>{label}</button>\n);\n```",
+            }
+        ]
+    if "summarize" in lower or "summary" in lower:
+        return [
+            {
+                "input": "Summarize: 'The quick brown fox jumps over the lazy dog repeatedly.'",
+                "output": "A fox repeatedly jumps over a dog.",
+            }
+        ]
+    return None
+
+
+def _render_raw_prompt(
+    role: str,
+    task: str,
+    input_fmt: str,
+    output_fmt: str,
+    constraints: List[str],
+    style: str,
+    safety: List[str],
+    examples: Optional[List[Dict[str, str]]] = None,
+    extra_context: Optional[str] = None,
+) -> str:
+    lines = [
+        f"## ROLE\nYou are a {role}.",
+        f"\n## TASK\n{task}",
+        f"\n## INPUT FORMAT\n{input_fmt}",
+        f"\n## OUTPUT FORMAT\n{output_fmt}",
+        "\n## CONSTRAINTS",
+    ]
+    for i, c in enumerate(constraints, 1):
+        lines.append(f"{i}. {c}")
+
+    lines.append(f"\n## STYLE & TONE\n{style}")
+
+    lines.append("\n## SAFETY GUIDELINES")
+    for i, s in enumerate(safety, 1):
+        lines.append(f"{i}. {s}")
+
+    if extra_context:
+        lines.append(f"\n## ADDITIONAL CONTEXT\n{extra_context}")
+
+    if examples:
+        lines.append("\n## FEW-SHOT EXAMPLES")
+        for ex in examples:
+            lines.append(f"**Input:** {ex['input']}")
+            lines.append(f"**Output:** {ex['output']}\n")
+
+    lines.append("\n---\n*Prompt generated by PromptForge — compatible with Google AI Studio.*")
+    return "\n".join(lines)

backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+pydantic>=2.7.0
+httpx>=0.27.0
+python-multipart>=0.0.9
+pytest>=8.2.0
+pytest-asyncio>=0.23.0
+httpx>=0.27.0

backend/schemas.py

@@ -0,0 +1,147 @@
+"""
+PromptForge — Pydantic schemas for request/response validation.
+"""
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+from enum import Enum
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# Enumerations
+# ---------------------------------------------------------------------------
+
+class OutputFormat(str, Enum):
+    text = "text"
+    json = "json"
+    both = "both"
+
+
+class AIProvider(str, Enum):
+    none = "none"
+    huggingface = "huggingface"
+    google = "google"
+
+
+# ---------------------------------------------------------------------------
+# Request models
+# ---------------------------------------------------------------------------
+
+class GenerateRequest(BaseModel):
+    instruction: str = Field(
+        ...,
+        min_length=5,
+        max_length=8000,
+        description="Raw user instruction, description, or task to convert into a structured prompt.",
+        example="Generate a TypeScript React component with TailwindCSS and unit tests.",
+    )
+    output_format: OutputFormat = Field(
+        OutputFormat.both,
+        description="Desired output format: 'text', 'json', or 'both'.",
+    )
+    provider: AIProvider = Field(
+        AIProvider.none,
+        description="Optional AI provider to use for iterative enhancement.",
+    )
+    api_key: Optional[str] = Field(
+        None,
+        description="API key for the selected provider (never stored in logs).",
+    )
+    enhance: bool = Field(
+        False,
+        description="If True, call the selected AI provider to iteratively refine the prompt.",
+    )
+    extra_context: Optional[str] = Field(
+        None,
+        max_length=2000,
+        description="Optional additional context or constraints for the prompt.",
+    )
+
+
+class ApproveRequest(BaseModel):
+    prompt_id: str = Field(..., description="ID of the pending prompt manifest to approve.")
+    edits: Optional[Dict[str, Any]] = Field(
+        None,
+        description="Optional user edits to apply before finalizing.",
+    )
+
+
+class ExportRequest(BaseModel):
+    prompt_id: str = Field(..., description="ID of the finalized prompt to export.")
+    export_format: OutputFormat = Field(OutputFormat.json)
+
+
+class RefineRequest(BaseModel):
+    prompt_id: str = Field(..., description="ID of a previously generated prompt to refine.")
+    feedback: str = Field(
+        ...,
+        min_length=3,
+        max_length=2000,
+        description="User feedback describing changes needed.",
+    )
+    provider: AIProvider = Field(AIProvider.none)
+    api_key: Optional[str] = Field(None)
+
+
+# ---------------------------------------------------------------------------
+# Inner prompt structure
+# ---------------------------------------------------------------------------
+
+class StructuredPrompt(BaseModel):
+    role: str = Field(..., description="The persona or role the AI should adopt.")
+    task: str = Field(..., description="Clear description of the task to perform.")
+    input_format: str = Field(..., description="Expected input format and fields.")
+    output_format: str = Field(..., description="Expected output format and fields.")
+    constraints: List[str] = Field(default_factory=list, description="Hard constraints the AI must respect.")
+    style: str = Field(..., description="Tone, style, and voice guidelines.")
+    safety: List[str] = Field(default_factory=list, description="Safety and ethical guardrails.")
+    examples: Optional[List[Dict[str, str]]] = Field(None, description="Few-shot examples (input/output pairs).")
+    raw_prompt_text: str = Field(..., description="Formatted plain-text prompt ready for copy-paste into Google AI Studio.")
+
+
+class PromptManifest(BaseModel):
+    prompt_id: str = Field(..., description="Unique identifier for this manifest.")
+    version: int = Field(1, description="Version counter for iterative refinement.")
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    instruction: str = Field(..., description="Original user instruction.")
+    status: str = Field("pending", description="pending | approved | exported")
+    structured_prompt: StructuredPrompt
+    enhancement_notes: Optional[str] = Field(None, description="Notes from AI enhancement pass.")
+
+
+# ---------------------------------------------------------------------------
+# Response models
+# ---------------------------------------------------------------------------
+
+class GenerateResponse(BaseModel):
+    success: bool
+    prompt_id: str
+    manifest: PromptManifest
+    message: str = "Manifest generated — awaiting approval."
+
+
+class ApproveResponse(BaseModel):
+    success: bool
+    prompt_id: str
+    message: str
+    finalized_prompt: StructuredPrompt
+
+
+class ExportResponse(BaseModel):
+    success: bool
+    prompt_id: str
+    data: Any  # JSON dict or plain text string
+
+
+class HistoryEntry(BaseModel):
+    prompt_id: str
+    version: int
+    created_at: datetime
+    instruction: str
+    status: str
+
+
+class HistoryResponse(BaseModel):
+    total: int
+    entries: List[HistoryEntry]

backend/store.py

@@ -0,0 +1,81 @@
+"""
+PromptForge — In-memory store with optional JSON-file persistence.
+In production, swap this for a proper database (PostgreSQL, SQLite, etc.).
+"""
+from __future__ import annotations
+import json
+import os
+import logging
+from copy import deepcopy
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from schemas import PromptManifest, HistoryEntry
+
+logger = logging.getLogger("promptforge.store")
+
+_DB: Dict[str, PromptManifest] = {}
+_LOG_DIR = Path(os.getenv("LOG_DIR", "logs"))
+_LOG_DIR.mkdir(parents=True, exist_ok=True)
+_PERSIST_FILE = _LOG_DIR / "prompt_history.json"
+
+
+# ---------------------------------------------------------------------------
+# CRUD
+# ---------------------------------------------------------------------------
+
+def save(manifest: PromptManifest) -> None:
+    _DB[manifest.prompt_id] = manifest
+    _persist()
+
+
+def get(prompt_id: str) -> Optional[PromptManifest]:
+    return _DB.get(prompt_id)
+
+
+def all_entries() -> List[HistoryEntry]:
+    return [
+        HistoryEntry(
+            prompt_id=m.prompt_id,
+            version=m.version,
+            created_at=m.created_at,
+            instruction=m.instruction,
+            status=m.status,
+        )
+        for m in sorted(_DB.values(), key=lambda x: x.created_at, reverse=True)
+    ]
+
+
+def delete(prompt_id: str) -> bool:
+    if prompt_id in _DB:
+        del _DB[prompt_id]
+        _persist()
+        return True
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Persistence
+# ---------------------------------------------------------------------------
+
+def _persist() -> None:
+    try:
+        data = [m.model_dump(mode="json") for m in _DB.values()]
+        _PERSIST_FILE.write_text(json.dumps(data, indent=2, default=str))
+    except Exception as exc:
+        logger.warning("Could not persist store: %s", exc)
+
+
+def load_from_disk() -> None:
+    """Call once at startup to reload previous sessions."""
+    if not _PERSIST_FILE.exists():
+        return
+    try:
+        raw = json.loads(_PERSIST_FILE.read_text())
+        for entry in raw:
+            m = PromptManifest.model_validate(entry)
+            _DB[m.prompt_id] = m
+        logger.info("Loaded %d prompts from disk.", len(_DB))
+    except Exception as exc:
+        logger.warning("Could not load persisted store: %s", exc)

backend/tests/test_promptforge.py

@@ -0,0 +1,204 @@
+"""
+PromptForge — Unit tests for prompt logic, schemas, and API routes.
+Run with: pytest tests/ -v
+"""
+from __future__ import annotations
+import sys
+import os
+
+# Make backend importable
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+import pytest
+from fastapi.testclient import TestClient
+
+from prompt_logic import build_manifest, apply_edits, refine_with_feedback
+from schemas import PromptManifest, GenerateRequest, OutputFormat, AIProvider
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def client():
+    from main import app
+    return TestClient(app)
+
+
+@pytest.fixture
+def sample_instruction():
+    return "Generate a TypeScript React component with TailwindCSS and unit tests."
+
+
+@pytest.fixture
+def sample_manifest(sample_instruction):
+    return build_manifest(sample_instruction)
+
+
+# ---------------------------------------------------------------------------
+# prompt_logic tests
+# ---------------------------------------------------------------------------
+
+class TestBuildManifest:
+    def test_returns_manifest_type(self, sample_manifest):
+        assert isinstance(sample_manifest, PromptManifest)
+
+    def test_status_is_pending(self, sample_manifest):
+        assert sample_manifest.status == "pending"
+
+    def test_version_is_1(self, sample_manifest):
+        assert sample_manifest.version == 1
+
+    def test_prompt_id_is_set(self, sample_manifest):
+        assert len(sample_manifest.prompt_id) == 36  # UUID4
+
+    def test_role_inferred_for_react(self, sample_manifest):
+        assert "Frontend" in sample_manifest.structured_prompt.role
+
+    def test_typescript_constraint_inferred(self, sample_manifest):
+        constraints = sample_manifest.structured_prompt.constraints
+        assert any("TypeScript" in c for c in constraints)
+
+    def test_tailwind_constraint_inferred(self, sample_manifest):
+        constraints = sample_manifest.structured_prompt.constraints
+        assert any("TailwindCSS" in c for c in constraints)
+
+    def test_raw_prompt_text_contains_role(self, sample_manifest):
+        raw = sample_manifest.structured_prompt.raw_prompt_text
+        assert "## ROLE" in raw
+
+    def test_raw_prompt_text_contains_task(self, sample_manifest):
+        raw = sample_manifest.structured_prompt.raw_prompt_text
+        assert "## TASK" in raw
+
+    def test_safety_guidelines_present(self, sample_manifest):
+        assert len(sample_manifest.structured_prompt.safety) >= 3
+
+    def test_extra_context_included(self):
+        m = build_manifest("Write a blog post.", extra_context="Keep it under 500 words.")
+        assert "500 words" in m.structured_prompt.raw_prompt_text
+
+    def test_summarize_instruction(self):
+        m = build_manifest("Summarize this document for me.")
+        assert "Summarizer" in m.structured_prompt.role
+
+    def test_unknown_instruction_gets_default_role(self):
+        m = build_manifest("Do something interesting.")
+        assert m.structured_prompt.role == "General AI Assistant"
+
+
+class TestApplyEdits:
+    def test_apply_role_edit(self, sample_manifest):
+        edited = apply_edits(sample_manifest, {"role": "Principal Software Engineer"})
+        assert edited.structured_prompt.role == "Principal Software Engineer"
+
+    def test_status_becomes_approved(self, sample_manifest):
+        edited = apply_edits(sample_manifest, {"task": "Updated task."})
+        assert edited.status == "approved"
+
+    def test_raw_text_regenerated(self, sample_manifest):
+        edited = apply_edits(sample_manifest, {"role": "XYZ"})
+        assert "XYZ" in edited.structured_prompt.raw_prompt_text
+
+
+class TestRefineWithFeedback:
+    def test_version_increments(self, sample_manifest):
+        refined = refine_with_feedback(sample_manifest, "Also add accessibility support.")
+        assert refined.version == 2
+
+    def test_same_prompt_id(self, sample_manifest):
+        refined = refine_with_feedback(sample_manifest, "Add dark mode support.")
+        assert refined.prompt_id == sample_manifest.prompt_id
+
+
+# ---------------------------------------------------------------------------
+# API route tests
+# ---------------------------------------------------------------------------
+
+class TestGenerateRoute:
+    def test_generate_returns_200(self, client, sample_instruction):
+        resp = client.post("/api/generate", json={"instruction": sample_instruction})
+        assert resp.status_code == 200
+
+    def test_generate_response_has_prompt_id(self, client, sample_instruction):
+        resp = client.post("/api/generate", json={"instruction": sample_instruction})
+        data = resp.json()
+        assert "prompt_id" in data
+        assert len(data["prompt_id"]) == 36
+
+    def test_generate_response_has_manifest(self, client, sample_instruction):
+        resp = client.post("/api/generate", json={"instruction": sample_instruction})
+        data = resp.json()
+        assert "manifest" in data
+        assert data["manifest"]["status"] == "pending"
+
+    def test_generate_short_instruction_422(self, client):
+        resp = client.post("/api/generate", json={"instruction": "hi"})
+        assert resp.status_code == 422
+
+    def test_generate_missing_instruction_422(self, client):
+        resp = client.post("/api/generate", json={})
+        assert resp.status_code == 422
+
+
+class TestApproveRoute:
+    def _generate(self, client, instruction="Build an API endpoint."):
+        resp = client.post("/api/generate", json={"instruction": instruction})
+        return resp.json()["prompt_id"]
+
+    def test_approve_returns_200(self, client):
+        pid = self._generate(client)
+        resp = client.post("/api/approve", json={"prompt_id": pid})
+        assert resp.status_code == 200
+
+    def test_approve_status_approved(self, client):
+        pid = self._generate(client)
+        resp = client.post("/api/approve", json={"prompt_id": pid})
+        assert resp.json()["success"] is True
+
+    def test_approve_unknown_id_404(self, client):
+        resp = client.post("/api/approve", json={"prompt_id": "00000000-0000-0000-0000-000000000000"})
+        assert resp.status_code == 404
+
+
+class TestExportRoute:
+    def _generate_and_approve(self, client):
+        pid = client.post("/api/generate", json={"instruction": "Write a Python script."}).json()["prompt_id"]
+        client.post("/api/approve", json={"prompt_id": pid})
+        return pid
+
+    def test_export_json_200(self, client):
+        pid = self._generate_and_approve(client)
+        resp = client.post("/api/export", json={"prompt_id": pid, "export_format": "json"})
+        assert resp.status_code == 200
+        data = resp.json()
+        assert isinstance(data["data"], dict)
+
+    def test_export_text_200(self, client):
+        pid = self._generate_and_approve(client)
+        resp = client.post("/api/export", json={"prompt_id": pid, "export_format": "text"})
+        assert resp.status_code == 200
+        assert isinstance(resp.json()["data"], str)
+
+    def test_export_unapproved_400(self, client):
+        pid = client.post("/api/generate", json={"instruction": "Write a Python script again."}).json()["prompt_id"]
+        resp = client.post("/api/export", json={"prompt_id": pid, "export_format": "json"})
+        assert resp.status_code == 400
+
+
+class TestHistoryRoute:
+    def test_history_returns_200(self, client):
+        resp = client.get("/api/history")
+        assert resp.status_code == 200
+
+    def test_history_has_total_field(self, client):
+        resp = client.get("/api/history")
+        assert "total" in resp.json()
+
+
+class TestHealthRoute:
+    def test_health_ok(self, client):
+        resp = client.get("/health")
+        assert resp.status_code == 200
+        assert resp.json()["status"] == "ok"

docker-compose.yml

@@ -0,0 +1,23 @@
+version: "3.9"
+
+services:
+  promptforge:
+    build: .
+    container_name: promptforge
+    restart: unless-stopped
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./logs:/app/logs          # Persist prompt history
+    environment:
+      # ── AI Provider keys (set in .env file, never commit) ──────────
+      # GOOGLE_API_KEY: set via .env or deployment secret manager
+      # HF_API_KEY: set via .env or deployment secret manager
+      LOG_DIR: /app/logs
+    env_file:
+      - .env                       # Create from .env.example
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 5s
+      retries: 3

frontend/client.js

@@ -0,0 +1,332 @@
+/**
+ * PromptForge — client.js
+ * Handles all API communication and UI state transitions.
+ */
+
+const API_BASE = "";        // Same origin; change to e.g. "http://localhost:8000" for dev
+let currentPromptId = null; // Tracks the active manifest
+
+// ── DOM refs ──────────────────────────────────────────────────────
+const $ = id => document.getElementById(id);
+const steps = {
+  input:     $("step-input"),
+  manifest:  $("step-manifest"),
+  finalized: $("step-finalized"),
+  refine:    $("step-refine"),
+};
+
+// ── Utility ───────────────────────────────────────────────────────
+function show(el)  { el.classList.remove("hidden"); }
+function hide(el)  { el.classList.add("hidden"); }
+function showStep(name) {
+  Object.values(steps).forEach(hide);
+  show(steps[name]);
+}
+
+function toast(msg, type = "info") {
+  const t = $("toast");
+  t.textContent = msg;
+  t.className = `toast ${type}`;
+  show(t);
+  setTimeout(() => hide(t), 3500);
+}
+
+function setLoading(btn, loading) {
+  btn.disabled = loading;
+  btn.dataset.originalText ??= btn.textContent;
+  btn.textContent = loading ? "⏳ Working…" : btn.dataset.originalText;
+}
+
+async function apiFetch(path, method = "GET", body = null) {
+  const opts = {
+    method,
+    headers: { "Content-Type": "application/json" },
+  };
+  if (body) opts.body = JSON.stringify(body);
+  const resp = await fetch(API_BASE + path, opts);
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || "Unknown error");
+  }
+  return resp.json();
+}
+
+// ── Step 1: Generate ──────────────────────────────────────────────
+$("btn-generate").addEventListener("click", async () => {
+  const instruction = $("instruction").value.trim();
+  if (!instruction || instruction.length < 5) {
+    toast("Please enter a meaningful instruction (min 5 characters).", "error");
+    return;
+  }
+
+  const provider  = $("provider").value;
+  const apiKey    = $("api-key").value.trim();
+  const extraCtx  = $("extra-context").value.trim();
+  const enhance   = provider !== "none" && !!apiKey;
+
+  const btn = $("btn-generate");
+  setLoading(btn, true);
+  try {
+    const data = await apiFetch("/api/generate", "POST", {
+      instruction,
+      output_format: "both",
+      provider,
+      api_key: apiKey || null,
+      enhance,
+      extra_context: extraCtx || null,
+    });
+
+    currentPromptId = data.prompt_id;
+    renderManifest(data.manifest);
+    show(steps.manifest);
+    steps.manifest.scrollIntoView({ behavior: "smooth" });
+    toast("✅ Manifest generated — review and approve.", "success");
+  } catch (e) {
+    toast(`Error: ${e.message}`, "error");
+  } finally {
+    setLoading(btn, false);
+  }
+});
+
+// ── Provider selector shows/hides API key field ───────────────────
+$("provider").addEventListener("change", () => {
+  const group = $("api-key-group");
+  group.style.display = $("provider").value !== "none" ? "flex" : "none";
+});
+
+// ── Render manifest into editable grid ───────────────────────────
+function renderManifest(manifest) {
+  const sp = manifest.structured_prompt;
+  const grid = $("manifest-grid");
+  grid.innerHTML = "";
+
+  const fields = [
+    { key: "role",           label: "Role",           value: sp.role,            full: false },
+    { key: "style",          label: "Style & Tone",   value: sp.style,           full: false },
+    { key: "task",           label: "Task",            value: sp.task,            full: true  },
+    { key: "input_format",   label: "Input Format",   value: sp.input_format,    full: false },
+    { key: "output_format",  label: "Output Format",  value: sp.output_format,   full: false },
+    { key: "constraints",    label: "Constraints",    value: sp.constraints.join("\n"), full: true },
+    { key: "safety",         label: "Safety",         value: sp.safety.join("\n"),     full: true },
+  ];
+
+  fields.forEach(f => {
+    const div = document.createElement("div");
+    div.className = `manifest-field${f.full ? " full" : ""}`;
+    div.innerHTML = `<label>${f.label}</label>
+      <textarea id="field-${f.key}" rows="${f.full ? 3 : 2}">${escapeHtml(f.value)}</textarea>`;
+    grid.appendChild(div);
+  });
+
+  $("manifest-json").textContent = JSON.stringify(manifest, null, 2);
+}
+
+// ── Step 2/3: Approve ─────────────────────────────────────────────
+$("btn-approve").addEventListener("click", async () => {
+  if (!currentPromptId) return;
+
+  // Collect edited field values
+  const edits = {};
+  ["role", "style", "task", "input_format", "output_format"].forEach(key => {
+    const el = $(`field-${key}`);
+    if (el) edits[key] = el.value.trim();
+  });
+  const cEl = $("field-constraints");
+  if (cEl) edits.constraints = cEl.value.trim().split("\n").filter(Boolean);
+  const sEl = $("field-safety");
+  if (sEl) edits.safety = sEl.value.trim().split("\n").filter(Boolean);
+
+  const btn = $("btn-approve");
+  setLoading(btn, true);
+  try {
+    const data = await apiFetch("/api/approve", "POST", {
+      prompt_id: currentPromptId,
+      edits,
+    });
+
+    renderFinalizedPrompt(data.finalized_prompt);
+    hide(steps.manifest);
+    show(steps.finalized);
+    steps.finalized.scrollIntoView({ behavior: "smooth" });
+    toast("✅ Prompt approved and finalized!", "success");
+  } catch (e) {
+    toast(`Approval failed: ${e.message}`, "error");
+  } finally {
+    setLoading(btn, false);
+  }
+});
+
+// ── Render finalized prompt ────────────────────────────────────────
+function renderFinalizedPrompt(sp) {
+  $("finalized-text").textContent = sp.raw_prompt_text;
+  $("finalized-json").textContent = JSON.stringify(sp, null, 2);
+}
+
+// ── Tabs ──────────────────────────────────────────────────────────
+document.querySelectorAll(".tab").forEach(tab => {
+  tab.addEventListener("click", () => {
+    const target = tab.dataset.tab;
+    document.querySelectorAll(".tab").forEach(t => t.classList.remove("active"));
+    tab.classList.add("active");
+    document.querySelectorAll(".tab-panel").forEach(p => hide(p));
+    show($(`tab-${target}`));
+  });
+});
+
+// ── Copy buttons ──────────────────────────────────────────────────
+document.querySelectorAll(".btn-copy").forEach(btn => {
+  btn.addEventListener("click", () => {
+    const pre = $(btn.dataset.target);
+    if (!pre) return;
+    navigator.clipboard.writeText(pre.textContent).then(() => {
+      const orig = btn.textContent;
+      btn.textContent = "✓ Copied!";
+      setTimeout(() => (btn.textContent = orig), 1800);
+    });
+  });
+});
+
+// ── Export ────────────────────────────────────────────────────────
+async function exportPrompt(format) {
+  if (!currentPromptId) return;
+  try {
+    const data = await apiFetch("/api/export", "POST", {
+      prompt_id: currentPromptId,
+      export_format: format,
+    });
+    const content  = typeof data.data === "string" ? data.data : JSON.stringify(data.data, null, 2);
+    const ext      = format === "text" ? "txt" : "json";
+    downloadFile(`prompt_${currentPromptId.slice(0,8)}.${ext}`, content);
+    toast(`⬇ Exported as .${ext}`, "success");
+  } catch (e) {
+    toast(`Export failed: ${e.message}`, "error");
+  }
+}
+
+$("btn-export-json").addEventListener("click", () => exportPrompt("json"));
+$("btn-export-txt").addEventListener("click",  () => exportPrompt("text"));
+
+function downloadFile(filename, content) {
+  const a = document.createElement("a");
+  a.href = URL.createObjectURL(new Blob([content], { type: "text/plain" }));
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(a.href);
+}
+
+// ── Refine ────────────────────────────────────────────────────────
+$("btn-refine").addEventListener("click", () => {
+  show(steps.refine);
+  steps.refine.scrollIntoView({ behavior: "smooth" });
+});
+$("btn-cancel-refine").addEventListener("click", () => hide(steps.refine));
+
+$("btn-submit-refine").addEventListener("click", async () => {
+  if (!currentPromptId) return;
+  const feedback = $("feedback").value.trim();
+  if (!feedback) { toast("Please enter feedback.", "error"); return; }
+
+  const btn = $("btn-submit-refine");
+  setLoading(btn, true);
+  try {
+    const data = await apiFetch("/api/refine", "POST", {
+      prompt_id: currentPromptId,
+      feedback,
+      provider: $("provider").value,
+      api_key: $("api-key").value.trim() || null,
+    });
+
+    currentPromptId = data.prompt_id;
+    renderManifest(data.manifest);
+    hide(steps.finalized);
+    hide(steps.refine);
+    show(steps.manifest);
+    $("feedback").value = "";
+    steps.manifest.scrollIntoView({ behavior: "smooth" });
+    toast(`🔁 Refined to v${data.manifest.version} — please re-approve.`, "success");
+  } catch (e) {
+    toast(`Refine failed: ${e.message}`, "error");
+  } finally {
+    setLoading(btn, false);
+  }
+});
+
+// ── Reset / New ───────────────────────────────────────────────────
+function resetAll() {
+  currentPromptId = null;
+  $("instruction").value = "";
+  $("extra-context").value = "";
+  $("feedback").value = "";
+  Object.values(steps).forEach(hide);
+  show(steps.input);
+  window.scrollTo({ top: 0, behavior: "smooth" });
+}
+
+$("btn-reset").addEventListener("click", resetAll);
+$("btn-new").addEventListener("click",   resetAll);
+
+// ── History ────────────────────────────────────────────────────────
+$("btn-load-history").addEventListener("click", loadHistory);
+
+async function loadHistory() {
+  try {
+    const data = await apiFetch("/api/history");
+    const tbody = $("history-body");
+
+    if (data.total === 0) {
+      tbody.innerHTML = `<tr><td colspan="6" class="muted center">No prompts generated yet.</td></tr>`;
+      return;
+    }
+
+    tbody.innerHTML = data.entries.map(e => `
+      <tr>
+        <td><code>${e.prompt_id.slice(0, 8)}…</code></td>
+        <td>${escapeHtml(e.instruction.slice(0, 60))}${e.instruction.length > 60 ? "…" : ""}</td>
+        <td>v${e.version}</td>
+        <td><span class="status-badge status-${e.status}">${e.status}</span></td>
+        <td>${new Date(e.created_at).toLocaleString()}</td>
+        <td>
+          <button class="btn-sm btn-secondary" onclick="loadPromptById('${e.prompt_id}')">Load</button>
+          <button class="btn-sm btn-secondary" onclick="deletePrompt('${e.prompt_id}')">🗑</button>
+        </td>
+      </tr>`).join("");
+  } catch (e) {
+    toast(`Could not load history: ${e.message}`, "error");
+  }
+}
+
+window.loadPromptById = async function(id) {
+  try {
+    const manifest = await apiFetch(`/api/history/${id}`);
+    currentPromptId = manifest.prompt_id;
+    renderManifest(manifest);
+    show(steps.manifest);
+    steps.manifest.scrollIntoView({ behavior: "smooth" });
+    toast("Manifest loaded from history.", "success");
+  } catch (e) {
+    toast(`Load failed: ${e.message}`, "error");
+  }
+};
+
+window.deletePrompt = async function(id) {
+  if (!confirm("Delete this prompt from history?")) return;
+  try {
+    await apiFetch(`/api/history/${id}`, "DELETE");
+    toast("Prompt deleted.", "success");
+    loadHistory();
+  } catch (e) {
+    toast(`Delete failed: ${e.message}`, "error");
+  }
+};
+
+// ── Helpers ────────────────────────────────────────────────────────
+function escapeHtml(str) {
+  return String(str)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+// ── Init ──────────────────────────────────────────────────────────
+loadHistory();

frontend/index.html

@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>PromptForge — Google AI Studio Prompt Generator</title>
+  <link rel="stylesheet" href="/static/style.css" />
+</head>
+<body>
+  <header>
+    <div class="header-inner">
+      <div class="logo">⚙️ PromptForge</div>
+      <span class="tagline">Structured prompts for Google AI Studio</span>
+    </div>
+  </header>
+
+  <main>
+    <!-- ── Step 0: Input ─────────────────────────────────────────── -->
+    <section id="step-input" class="card">
+      <h2><span class="step-badge">STEP 1</span> Enter Your Instruction</h2>
+
+      <label for="instruction">Raw instruction / task description</label>
+      <textarea id="instruction" rows="5"
+        placeholder="e.g. Generate a TypeScript React component with TailwindCSS and unit tests."></textarea>
+
+      <label for="extra-context">Additional context (optional)</label>
+      <textarea id="extra-context" rows="2"
+        placeholder="e.g. The component should be accessible and support dark mode."></textarea>
+
+      <div class="row-two">
+        <div class="field-group">
+          <label for="provider">AI Enhancement Provider</label>
+          <select id="provider">
+            <option value="none">None (local only)</option>
+            <option value="google">Google Gemini</option>
+            <option value="huggingface">Hugging Face</option>
+          </select>
+        </div>
+        <div class="field-group" id="api-key-group" style="display:none;">
+          <label for="api-key">API Key <span class="muted">(never stored)</span></label>
+          <input id="api-key" type="password" placeholder="Paste your API key here..." />
+        </div>
+      </div>
+
+      <button id="btn-generate" class="btn-primary">⚡ Generate Prompt Manifest</button>
+    </section>
+
+    <!-- ── Step 1: Manifest preview ──────────────────────────────── -->
+    <section id="step-manifest" class="card hidden">
+      <h2><span class="step-badge">STEP 2</span> Review Manifest</h2>
+      <p class="muted">Review the generated manifest. Edit any field below, then approve.</p>
+
+      <div id="manifest-grid" class="manifest-grid"></div>
+
+      <details>
+        <summary>📋 Raw JSON Manifest</summary>
+        <pre id="manifest-json"></pre>
+      </details>
+
+      <div class="action-row">
+        <button id="btn-approve" class="btn-primary">✅ Approve &amp; Finalize</button>
+        <button id="btn-reset" class="btn-secondary">↩ Start Over</button>
+      </div>
+    </section>
+
+    <!-- ── Step 2: Finalized prompt ──────────────────────────────── -->
+    <section id="step-finalized" class="card hidden">
+      <h2><span class="step-badge">STEP 3</span> Finalized Prompt</h2>
+      <p class="muted">Your structured prompt is ready. Copy it directly into Google AI Studio.</p>
+
+      <div class="tab-bar">
+        <button class="tab active" data-tab="text">📄 Plain Text</button>
+        <button class="tab" data-tab="json">{ } JSON</button>
+      </div>
+
+      <div id="tab-text" class="tab-panel">
+        <pre id="finalized-text"></pre>
+        <button class="btn-copy" data-target="finalized-text">📋 Copy</button>
+      </div>
+      <div id="tab-json" class="tab-panel hidden">
+        <pre id="finalized-json"></pre>
+        <button class="btn-copy" data-target="finalized-json">📋 Copy</button>
+      </div>
+
+      <div class="action-row">
+        <button id="btn-export-json" class="btn-secondary">⬇ Export JSON</button>
+        <button id="btn-export-txt" class="btn-secondary">⬇ Export Text</button>
+        <button id="btn-refine" class="btn-secondary">🔁 Refine with Feedback</button>
+        <button id="btn-new" class="btn-primary">➕ New Prompt</button>
+      </div>
+    </section>
+
+    <!-- ── Refine panel ───────────────────────────────────────────── -->
+    <section id="step-refine" class="card hidden">
+      <h2><span class="step-badge">STEP 5</span> Refine Prompt</h2>
+      <label for="feedback">Your feedback / change requests</label>
+      <textarea id="feedback" rows="3"
+        placeholder="e.g. Add accessibility constraints. Use React hooks only."></textarea>
+      <div class="action-row">
+        <button id="btn-submit-refine" class="btn-primary">🔁 Submit Refinement</button>
+        <button id="btn-cancel-refine" class="btn-secondary">Cancel</button>
+      </div>
+    </section>
+
+    <!-- ── History ────────────────────────────────────────────────── -->
+    <section id="section-history" class="card">
+      <h2>📜 Prompt History</h2>
+      <button id="btn-load-history" class="btn-secondary btn-sm">Refresh History</button>
+      <table id="history-table">
+        <thead>
+          <tr><th>ID</th><th>Instruction</th><th>Version</th><th>Status</th><th>Date</th><th></th></tr>
+        </thead>
+        <tbody id="history-body">
+          <tr><td colspan="6" class="muted center">Click "Refresh History" to load.</td></tr>
+        </tbody>
+      </table>
+    </section>
+  </main>
+
+  <!-- Toast notification -->
+  <div id="toast" class="toast hidden"></div>
+
+  <footer>
+    <p>PromptForge v1.0 · <a href="/docs" target="_blank">API Docs</a> · Built with FastAPI + Vanilla JS</p>
+  </footer>
+
+  <script src="/static/client.js"></script>
+</body>
+</html>

frontend/style.css

@@ -0,0 +1,284 @@
+/* PromptForge — style.css */
+
+:root {
+  --bg: #0f1117;
+  --surface: #1a1d27;
+  --surface2: #22263a;
+  --border: #2e3350;
+  --accent: #5b8df6;
+  --accent-hover: #3d6fe0;
+  --success: #34d399;
+  --warning: #fbbf24;
+  --danger: #f87171;
+  --text: #e4e7f0;
+  --text-muted: #7c84a3;
+  --radius: 10px;
+  --font: 'Inter', system-ui, sans-serif;
+  --mono: 'Fira Code', 'Cascadia Code', monospace;
+}
+
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--font);
+  font-size: 15px;
+  line-height: 1.6;
+  min-height: 100vh;
+}
+
+/* ── Header ──────────────────────────────────────────────────── */
+header {
+  background: linear-gradient(135deg, #1e2336 0%, #151824 100%);
+  border-bottom: 1px solid var(--border);
+  padding: 14px 24px;
+  position: sticky;
+  top: 0;
+  z-index: 100;
+  backdrop-filter: blur(6px);
+}
+.header-inner { display: flex; align-items: center; gap: 16px; max-width: 960px; margin: 0 auto; }
+.logo { font-size: 1.25rem; font-weight: 700; letter-spacing: -0.3px; }
+.tagline { color: var(--text-muted); font-size: 0.85rem; }
+
+/* ── Main layout ──────────────────────────────────────────────── */
+main {
+  max-width: 960px;
+  margin: 32px auto;
+  padding: 0 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 24px;
+}
+
+/* ── Cards ──────────────────────────────────────────────────────── */
+.card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 28px 30px;
+}
+.card h2 {
+  font-size: 1.05rem;
+  font-weight: 600;
+  margin-bottom: 18px;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+.step-badge {
+  background: var(--accent);
+  color: #fff;
+  font-size: 0.65rem;
+  font-weight: 700;
+  letter-spacing: 0.5px;
+  padding: 3px 8px;
+  border-radius: 20px;
+}
+
+/* ── Form elements ─────────────────────────────────────────────── */
+label {
+  display: block;
+  margin-bottom: 6px;
+  font-size: 0.875rem;
+  color: var(--text-muted);
+  font-weight: 500;
+}
+textarea, input[type="password"], select {
+  width: 100%;
+  background: var(--surface2);
+  border: 1px solid var(--border);
+  border-radius: 7px;
+  color: var(--text);
+  font-family: var(--font);
+  font-size: 0.9rem;
+  padding: 10px 14px;
+  resize: vertical;
+  transition: border-color 0.2s;
+  margin-bottom: 16px;
+}
+textarea:focus, input:focus, select:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+select option { background: var(--surface2); }
+
+.row-two {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+}
+.field-group { display: flex; flex-direction: column; }
+.field-group label { margin-bottom: 6px; }
+.field-group textarea,
+.field-group input,
+.field-group select { margin-bottom: 0; }
+
+/* ── Buttons ────────────────────────────────────────────────────── */
+.btn-primary, .btn-secondary {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  border: none;
+  border-radius: 7px;
+  cursor: pointer;
+  font-family: var(--font);
+  font-size: 0.9rem;
+  font-weight: 600;
+  padding: 10px 20px;
+  transition: background 0.2s, transform 0.1s;
+}
+.btn-primary {
+  background: var(--accent);
+  color: #fff;
+}
+.btn-primary:hover { background: var(--accent-hover); transform: translateY(-1px); }
+.btn-primary:active { transform: translateY(0); }
+
+.btn-secondary {
+  background: var(--surface2);
+  color: var(--text);
+  border: 1px solid var(--border);
+}
+.btn-secondary:hover { border-color: var(--accent); color: var(--accent); }
+
+.btn-sm { font-size: 0.8rem; padding: 7px 14px; }
+
+.btn-copy {
+  background: var(--surface2);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 0.8rem;
+  margin-top: 8px;
+  padding: 6px 14px;
+  transition: color 0.2s;
+}
+.btn-copy:hover { color: var(--success); border-color: var(--success); }
+
+.action-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-top: 20px;
+}
+
+/* ── Manifest grid ──────────────────────────────────────────────── */
+.manifest-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+  margin-bottom: 20px;
+}
+.manifest-field { display: flex; flex-direction: column; }
+.manifest-field.full { grid-column: 1 / -1; }
+.manifest-field label { font-size: 0.78rem; color: var(--accent); text-transform: uppercase; letter-spacing: 0.4px; margin-bottom: 4px; }
+.manifest-field textarea,
+.manifest-field input {
+  margin-bottom: 0;
+  font-size: 0.85rem;
+  min-height: 70px;
+}
+
+/* ── Tabs ───────────────────────────────────────────────────────── */
+.tab-bar { display: flex; gap: 4px; margin-bottom: 14px; }
+.tab {
+  background: none;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-family: var(--font);
+  font-size: 0.85rem;
+  padding: 7px 16px;
+  transition: all 0.2s;
+}
+.tab.active { background: var(--accent); border-color: var(--accent); color: #fff; }
+
+/* ── Pre / code blocks ──────────────────────────────────────────── */
+pre {
+  background: #0a0c14;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  color: #c9d1d9;
+  font-family: var(--mono);
+  font-size: 0.82rem;
+  line-height: 1.5;
+  overflow-x: auto;
+  padding: 16px 18px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+details summary {
+  cursor: pointer;
+  color: var(--text-muted);
+  font-size: 0.85rem;
+  margin-bottom: 10px;
+  user-select: none;
+}
+details[open] summary { color: var(--text); }
+
+/* ── History table ──────────────────────────────────────────────── */
+table { width: 100%; border-collapse: collapse; margin-top: 14px; font-size: 0.85rem; }
+th { color: var(--text-muted); font-weight: 600; padding: 8px 10px; text-align: left; border-bottom: 1px solid var(--border); }
+td { padding: 9px 10px; border-bottom: 1px solid #1e2236; vertical-align: middle; }
+tr:hover td { background: var(--surface2); }
+td.center { text-align: center; }
+
+.status-badge {
+  border-radius: 20px;
+  font-size: 0.72rem;
+  font-weight: 700;
+  letter-spacing: 0.3px;
+  padding: 3px 9px;
+  text-transform: uppercase;
+}
+.status-pending  { background: #2d2a1a; color: var(--warning); }
+.status-approved { background: #162820; color: var(--success); }
+.status-exported { background: #1a1f36; color: var(--accent); }
+
+/* ── Utility ────────────────────────────────────────────────────── */
+.hidden { display: none !important; }
+.muted { color: var(--text-muted); font-size: 0.875rem; margin-bottom: 12px; }
+
+/* ── Toast ──────────────────────────────────────────────────────── */
+.toast {
+  position: fixed;
+  bottom: 28px;
+  right: 28px;
+  background: var(--surface2);
+  border: 1px solid var(--border);
+  border-radius: 9px;
+  box-shadow: 0 4px 24px rgba(0,0,0,0.4);
+  color: var(--text);
+  font-size: 0.875rem;
+  font-weight: 500;
+  max-width: 340px;
+  padding: 13px 18px;
+  z-index: 999;
+  animation: slideIn 0.25s ease;
+}
+.toast.success { border-color: var(--success); color: var(--success); }
+.toast.error   { border-color: var(--danger);  color: var(--danger);  }
+@keyframes slideIn { from { opacity:0; transform: translateY(10px); } to { opacity:1; transform: translateY(0); } }
+
+/* ── Footer ──────────────────────────────────────────────────────── */
+footer {
+  text-align: center;
+  color: var(--text-muted);
+  font-size: 0.8rem;
+  padding: 24px 0 32px;
+}
+footer a { color: var(--accent); text-decoration: none; }
+footer a:hover { text-decoration: underline; }
+
+/* ── Responsive ──────────────────────────────────────────────────── */
+@media (max-width: 640px) {
+  .row-two, .manifest-grid { grid-template-columns: 1fr; }
+  .manifest-field.full { grid-column: 1; }
+  .card { padding: 20px 16px; }
+  main { margin: 16px auto; }
+}

promptforge.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db09504dcb45573eda133e793bed9b319582e61ce7b6688827dd656d5f2f2cbf
+size 27489

upload.bat

@@ -0,0 +1,28 @@
+@echo off
+echo ================================================
+echo   PromptForge - Hugging Face Uploader
+echo ================================================
+echo.
+
+:: Check Python
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo [ERROR] Python not found. Install from https://python.org
+    pause
+    exit /b 1
+)
+
+:: Install huggingface_hub if needed
+echo [1/2] Checking huggingface_hub...
+pip show huggingface_hub >nul 2>&1
+if errorlevel 1 (
+    echo       Installing huggingface_hub...
+    pip install huggingface_hub
+)
+
+:: Run uploader
+echo [2/2] Running uploader...
+echo.
+python upload_to_hf.py
+
+pause