hfpr

.dockerignore

@@ -1,11 +1,2 @@
-.venv/
-__pycache__/
-*.pyc
-.env
-.nottracked/
-.git/
-.gitignore
-AGENTS.md
-README.md
-LICENSE
-*.md
+.venv/  __pycache__/  *.pyc  .env  .nottracked/  frontend/
+.git/  .gitignore  AGENTS.md  README.md  LICENSE  *.md

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -2,22 +2,12 @@ FROM python:3.12-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    libpango-1.0-0 \
-    libpangocairo-1.0-0 \
-    libgdk-pixbuf-2.0-0 \
-    libffi-dev \
-    poppler-utils \
-    shared-mime-info \
-    && rm -rf /var/lib/apt/lists/*
-
 COPY requirements.txt .
 
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY backend/ .
-COPY frontend/ frontend/
 
 EXPOSE 7860
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,92 +1,10 @@
 ---
 title: Curriculum Backend
-colorFrom: blue
+emoji: 👁
+colorFrom: pink
 colorTo: gray
 sdk: docker
-app_port: 7860
 pinned: false
 ---
 
-# Curriculum Automation
-
-## Doc link
-
-https://lonelyguy-se1.github.io/PESU-Curriculum-Automation/
-
-## Phase 1 Flow Proposal
-
-```mermaid id="phase1-flow"
-flowchart TD
-
-    A[Professor opens form] --> B[Enter course details]
-    B --> C[Submit content, semester, credits, department, books]
-
-    C --> D[FastAPI receives submission]
-    D --> E[Check mandatory fields]
-
-    E -->|Invalid| F[Reject submission]
-    F --> G[Email professor with reasons]
-    G --> H[Professor opens edit link]
-    H --> I[Cached form shows old data and flagged issues]
-    I --> C
-
-    E -->|Valid| J[Generate derived fields]
-    J --> J1[Course code]
-    J --> J2[Credit pattern]
-    J --> J3[Course type]
-    J --> J4[Template data]
-
-    J1 --> K[AI refinement]
-    J2 --> K
-    J3 --> K
-    J4 --> K
-
-    K --> K1[Refine content]
-    K --> K2[Generate prelude]
-    K --> K3[Generate objectives]
-    K --> K4[Generate outcomes]
-    K --> K5[Recommend tools]
-
-    K1 --> L[Rubric check]
-    K2 --> L
-    K3 --> L
-    K4 --> L
-    K5 --> L
-
-    L -->|Low score| M[Reject draft]
-    M --> N[Store flagged issues]
-    N --> G
-
-    L -->|Pass| O[Create draft record]
-    O --> P[Render preview with Jinja2]
-
-    P --> Q[Faculty or admin review]
-
-    Q -->|Rejected| R[Store rejection reasons]
-    R --> G
-
-    Q -->|Accepted| S[Update remote database]
-    S --> T[Update curriculum template fields]
-    T --> U[Keep incomplete template pending]
-
-    U --> V{All course submissions received?}
-
-    V -->|No| W[Wait for remaining professors]
-    W --> U
-
-    V -->|Yes| X[Compile final curriculum document]
-    X --> Y[Final review]
-    Y --> Z[Export final PDF or DOCX]
-```
-
-## Phase 1 Summary
-
-Professors submit only the required academic material.
-
-The system generates derived fields, refines the content, checks it using a rubric, and stores accepted drafts in a remote database.
-
-Rejected submissions are returned by email with reasons. The professor gets an edit link where previous data is already cached and flagged issues are shown.
-
-Accepted submissions do not immediately become the final document. They update the shared curriculum template and remain pending until all required course submissions are received.
-
-The final curriculum document is compiled only after every required course entry is complete.
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

backend/app/api.py

@@ -1,8 +1,60 @@
 from fastapi import APIRouter
+from fastapi.responses import HTMLResponse
+from jinja2 import Environment, FileSystemLoader
+from pydantic import BaseModel,Field, field_validator
+from typing import Literal
 
-from app.routes import agent, chat, courses, health, preview, refined, submissions, versions
+from app.preview import build_course_preview
+from app.supabase import supabase
 
-router = APIRouter()
+router=APIRouter()
 
-for route in (health, submissions, preview, refined, agent, chat, versions, courses):
-    router.include_router(route.router)
+templates=Environment(loader=FileSystemLoader("app/templates"))
+
+class CourseSubmission(BaseModel):
+    faculty_email: str=Field(min_length=3, max_length=254)
+    course_title: str=Field(min_length=3, max_length=150)
+    offering_department: Literal["MA", "CS", "UZ"]
+    target_department: Literal["CSE", "ECE", "ME", "BT", "EEE", "AIML"]
+    semester: Literal["1", "2", "3", "4", "5", "6", "7", "8"]
+    credit_category: Literal["0", "2", "4", "5"]
+    raw_course_content: str=Field(min_length=50)
+    text_books: str=Field(min_length=5)
+    reference_books: str=""
+    preferred_tools: str=""
+
+    @field_validator(
+        "faculty_email", "course_title", "raw_course_content", "text_books", "reference_books", "preferred_tools", mode="before",)
+    @classmethod
+    def strip(cls, v):
+        return v.strip() if isinstance(v, str) else v
+    
+@router.post("/submissions")
+def receive(data: CourseSubmission):
+    """
+    print("=== NEW SUBMISSION ===")
+    for field, values in data.model_dump().items():
+        print(f"{field}: {values}")
+    print("======================")
+    return {"message": "Submission received successfully!", "submission": data.model_dump()}
+    """
+    
+    data_dict=data.model_dump()
+    data_dict["status"]="pending"
+    result=supabase.table("submissions").insert(data_dict).execute()
+    print("New Submission Received! Course Title: ", data.course_title)
+    return {"message":"Submission Received!", "submission":result.data[0]}
+
+@router.get("/preview/semester/{sem}/courses")
+def list_courses(sem:str):  # sem will be used once semester column is added
+    result=supabase.table("refined_submissions").select("id").execute()
+    rows: list[dict] = result.data
+    return {"course_ids": [r["id"] for r in rows]}
+
+@router.get("/preview/course/{refined_id}")
+def preview_course(refined_id:int):
+    result=supabase.table("refined_submissions").select("*").eq("id", refined_id).single().execute()
+    row: dict = result.data
+    course=build_course_preview(row)
+    html=templates.get_template("jinja_sample.html").render(course=course, curriculum_year="", page_number="")
+    return HTMLResponse(content=html)

backend/app/main.py

@@ -1,35 +1,11 @@
-import os
 from pathlib import Path
 
-import sentry_sdk
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
-from dotenv import load_dotenv
-
-load_dotenv(Path(__file__).resolve().parents[2] / ".env")
-
-sentry_dsn = os.getenv("SENTRY_DSN", "").strip()
-if sentry_dsn:
-    sentry_config = {"dsn": sentry_dsn, "environment": os.getenv("SENTRY_ENVIRONMENT", "").strip() or "production"}
-    sentry_release = os.getenv("SENTRY_RELEASE", "").strip()
-    if sentry_release:
-        sentry_config["release"] = sentry_release
-    sentry_sdk.init(**sentry_config)
 
 from app.api import router
 
-
-def frontend_directory():
-    app_root = Path(__file__).resolve().parents[1]
-    candidates = (
-        app_root / "frontend",
-        app_root.parent / "frontend",
-        app_root.parent.parent / "frontend",
-        Path("/frontend"),
-    )
-    return next((path for path in candidates if path.exists()), None)
-
 app = FastAPI(title="PESU Curriculum Automation")
 
 app.add_middleware(
@@ -41,7 +17,5 @@ app.add_middleware(
 
 app.include_router(router, prefix="/api")
 
-frontend_dir = frontend_directory()
-if not frontend_dir:
-    raise RuntimeError("Frontend directory not found")
-app.mount("/", StaticFiles(directory=frontend_dir, html=True), name="frontend")
+if Path("../frontend").exists():
+    app.mount("/", StaticFiles(directory="../frontend", html=True), name="frontend")

backend/app/models/__init__.py

@@ -1 +0,0 @@
-

backend/app/models/agent.py

@@ -1,23 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class AgentDraftPayload(BaseModel):
-    refined_id: int
-    fields: dict
-    reason: str = ""
-
-
-class AgentDocumentCoursePayload(BaseModel):
-    refined_id: int
-    fields: dict
-
-
-class AgentDocumentDraftPayload(BaseModel):
-    courses: list[AgentDocumentCoursePayload] = Field(min_length=1)
-    reason: str = ""
-    curriculum_version_id: int | None = None
-    uploaded_document_id: str = ""
-
-
-class AgentToolPayload(BaseModel):
-    arguments: dict = Field(default_factory=dict)

backend/app/models/chat.py

@@ -1,26 +0,0 @@
-from pydantic import BaseModel, Field, field_validator
-
-
-class ChatSessionPayload(BaseModel):
-    refined_id: int | None = None
-    document_draft_id: int | None = None
-    title: str = ""
-
-
-class ChatSessionTitlePayload(BaseModel):
-    title: str = Field(min_length=1, max_length=120)
-
-    @field_validator("title", mode="before")
-    @classmethod
-    def strip_title(cls, value):
-        return value.strip() if isinstance(value, str) else value
-
-
-class ChatMessagePayload(BaseModel):
-    content: str = ""
-    metadata: dict = Field(default_factory=dict)
-
-    @field_validator("content", mode="before")
-    @classmethod
-    def strip_content(cls, value):
-        return value.strip() if isinstance(value, str) else value

backend/app/models/submission.py

@@ -1,21 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class CourseSubmission(BaseModel):
-    faculty_email: str = Field(min_length=3, max_length=254)
-    course_title: str = Field(min_length=3, max_length=150)
-    offering_department: Literal["MA", "CS", "UZ"]
-    target_department: Literal["CSE", "ECE", "ME", "BT", "EEE", "AIML"]
-    semester: Literal["1", "2", "3", "4", "5", "6", "7", "8"]
-    credit_category: Literal["0", "2", "4", "5"]
-    raw_course_content: str = Field(min_length=50)
-    text_books: str = Field(min_length=5)
-    reference_books: str = ""
-    preferred_tools: str = ""
-
-    @field_validator("faculty_email", "course_title", "raw_course_content", "text_books", "reference_books", "preferred_tools", mode="before")
-    @classmethod
-    def strip(cls, value):
-        return value.strip() if isinstance(value, str) else value

backend/app/preview.py

@@ -1,81 +1,23 @@
 import json
 
-from app.services.books import parse_books
-from app.services.deterministic import compute_course_type, compute_hours, compute_program
-
-
-def _lines(value) -> list[str]:
-    if not value:
-        return []
-    if isinstance(value, list):
-        return [str(item).strip() for item in value if str(item).strip()]
-    return [line.strip() for line in str(value).splitlines() if line.strip()]
-
-
-def _content(row: dict) -> dict:
-    raw = row.get("refined_content") or {}
-    if isinstance(raw, dict):
-        return raw
-    if isinstance(raw, str) and raw.strip():
-        return json.loads(raw)
-    return {}
-
-
-def _text(*values) -> str:
-    for value in values:
-        if isinstance(value, str):
-            text = value.strip()
-            if text and text != "-":
-                return text
-    return ""
-
 
 def build_course_preview(row: dict) -> dict:
-    content = _content(row)
-    submission = row.get("_submission") or {}
-    credit_category = str(submission.get("credit_category") or row.get("credit_category") or content.get("credits") or "")
-    target_department = str(submission.get("target_department") or "")
-
-    hours = {
-        "lecture_hours": row.get("lecture_hours", content.get("lecture_hours", 0)),
-        "tutorial_hours": row.get("tutorial_hours", content.get("tutorial_hours", 0)),
-        "practical_hours": row.get("practical_hours", content.get("practical_hours", 0)),
-        "self_study": row.get("self_study", content.get("self_study", 0)),
-        "credits": row.get("credits", content.get("credits", 0)),
-    }
-    if credit_category and not any(hours.values()):
-        hours = compute_hours(credit_category)
-
-    program = row.get("program") or content.get("program") or ""
-    if target_department and not program:
-        program = compute_program(target_department)
-
-    course_type = row.get("course_type") or content.get("course_type") or ""
-    if credit_category and not course_type:
-        course_type = compute_course_type(credit_category)
-
-    practical_hours = int(hours["practical_hours"] or 0)
-    status = str(row.get("status") or content.get("status") or "")
+    content = json.loads(row.get("refined_content") or "{}")
     return {
-        "course_code": str(row.get("course_code") or content.get("course_code") or ""),
-        "course_title": str(row.get("course_title") or content.get("course_title") or ""),
-        "program": str(program),
-        "lecture_hours": str(hours["lecture_hours"]),
-        "tutorial_hours": str(hours["tutorial_hours"]),
-        "practical_hours": str(practical_hours),
-        "self_study": str(hours["self_study"]),
-        "credits": str(hours["credits"]),
-        "semester": str(row.get("semester") or content.get("semester") or ""),
-        "course_type": str(course_type),
-        "status": status,
-        "render_detail": status != "summary_only",
-        "tools_languages": _text(row.get("tools_languages"), content.get("tools_languages"), submission.get("preferred_tools")),
-        "desirable_knowledge": _text(row.get("desirable_knowledge"), content.get("desirable_knowledge")),
-        "prelude": row.get("prelude") or content.get("prelude") or "",
-        "objectives": _lines(row.get("objectives") or content.get("objectives"))[:4],
-        "course_outcomes": _lines(row.get("course_outcomes") or content.get("course_outcomes"))[:4],
-        "units": row.get("units") or content.get("units") or [],
-        "lab_experiments": _lines(row.get("lab_experiments") or content.get("lab_experiments"))[:10] if practical_hours else [],
-        "text_books": parse_books(row.get("text_books") or content.get("text_books")) or parse_books(submission.get("text_books")),
-        "reference_books": parse_books(row.get("reference_books") or content.get("reference_books")) or parse_books(submission.get("reference_books")),
-    }
+        "course_code": str(content.get("course_code", "")),
+        "course_title": str(content.get("course_title", "")),
+        "program": str(content.get("program", "")),
+        "lecture_hours": str(content.get("lecture_hours", 0)),
+        "tutorial_hours": str(content.get("tutorial_hours", 0)),
+        "practical_hours": str(content.get("practical_hours", 0)),
+        "self_study": str(content.get("self_study", 0)),
+        "credits": str(content.get("credits", 0)),
+        "semester": str(content.get("semester", "")),
+        "course_type": str(content.get("course_type", "")),
+        "tools_languages": str(content.get("tools_languages", "")),
+        "desirable_knowledge": str(content.get("desirable_knowledge", "")),
+        "prelude": row.get("prelude") or content.get("prelude", ""),
+        "objectives": row.get("objectives") or content.get("objectives", []),
+        "units": content.get("units", []),
+        "lab_experiments": content.get("lab_experiments", []),
+    }

backend/app/rendering.py

@@ -1,73 +0,0 @@
-import re
-from pathlib import Path
-
-from jinja2 import Environment, FileSystemLoader, select_autoescape
-from markupsafe import Markup, escape
-
-APP_DIR = Path(__file__).resolve().parent
-
-
-def _find_frontend_dir() -> Path:
-    app_root = APP_DIR.parent
-    candidates = (
-        app_root / "frontend",
-        app_root.parent / "frontend",
-        app_root.parent.parent / "frontend",
-        Path("/frontend"),
-    )
-    result = next((p for p in candidates if p.exists()), None)
-    if result is None:
-        raise RuntimeError("Frontend directory not found; cannot resolve image assets for PDF rendering")
-    return result
-
-
-FRONTEND_DIR = _find_frontend_dir()
-templates = Environment(loader=FileSystemLoader(APP_DIR / "templates"), autoescape=select_autoescape(["html", "xml"]))
-URL_RE = re.compile(r"https?://[^\s<>()]+")
-YEAR_RE = re.compile(r"\d{4}")
-
-
-def linkify(value: str) -> Markup:
-    text = str(value or "")
-    parts = []
-    last = 0
-    for match in URL_RE.finditer(text):
-        raw_url = match.group(0)
-        url = raw_url.rstrip(".,;:)]}")
-        trailing = raw_url[len(url) :]
-        safe_url = escape(url)
-        parts.append(escape(text[last : match.start()]))
-        parts.append(Markup(f'<a class="resource-link" href="{safe_url}" target="_blank" rel="noopener noreferrer">{safe_url}</a>'))
-        parts.append(escape(trailing))
-        last = match.end()
-    parts.append(escape(text[last:]))
-    return Markup("".join(str(part) for part in parts))
-
-
-def batch_start_year(semester, curriculum_year: str) -> int | None:
-    match = YEAR_RE.search(str(curriculum_year or ""))
-    if not match:
-        return None
-    try:
-        sem = int(semester)
-    except (TypeError, ValueError):
-        return None
-    return int(match.group()) - ((sem - 1) // 2)
-
-
-def batch_label(semester, curriculum_year: str) -> str:
-    start = batch_start_year(semester, curriculum_year)
-    return f"({start}-{(start + 4) % 100:02d} BATCH)" if start else ""
-
-
-def course_code_for_year(value: str, semester, curriculum_year: str) -> str:
-    code = str(value or "")
-    start = batch_start_year(semester, curriculum_year)
-    if not start or len(code) < 5 or code[:2] not in {"UE", "UZ"} or not code[2:4].isdigit():
-        return code
-    return f"{code[:2]}{start % 100:02d}{code[4:]}"
-
-
-templates.filters["linkify"] = linkify
-templates.filters["course_code_for_year"] = course_code_for_year
-templates.globals["batch_label"] = batch_label

backend/app/routes/__init__.py

@@ -1 +0,0 @@
-

backend/app/routes/agent.py

@@ -1,225 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from fastapi.responses import HTMLResponse
-from postgrest.exceptions import APIError
-
-from app.models.agent import AgentDocumentDraftPayload, AgentDraftPayload, AgentToolPayload
-from app.rendering import templates
-from app.services.agent_tools import call_tool, list_tool_schemas
-from app.services.curriculum import draft_record, load_agent_draft, load_document_draft, selected_curriculum_year, update_refined_fields
-from app.services.diffing import diff_course
-from app.services.errors import database_http_exception
-from app.supabase import supabase
-
-router = APIRouter()
-
-
-@router.post("/agent/diff")
-def compare_course(payload: dict):
-    current = payload.get("current")
-    proposed = payload.get("proposed")
-    if not isinstance(current, dict) or not isinstance(proposed, dict):
-        raise HTTPException(status_code=400, detail="current and proposed are required")
-    return diff_course(current, proposed)
-
-
-@router.post("/agent/drafts")
-def create_agent_draft(payload: AgentDraftPayload):
-    try:
-        record = draft_record(payload.refined_id, payload.fields, payload.reason)
-        result = supabase.table("agent_drafts").insert(record).execute()
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"message": "Draft created", "draft": result.data[0]}
-
-
-@router.get("/agent/drafts")
-def list_agent_drafts():
-    try:
-        rows = supabase.table("agent_drafts").select("*").order("id", desc=True).limit(100).execute().data
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {
-        "drafts": [
-            {
-                "id": row["id"],
-                "refined_id": row["refined_id"],
-                "status": row.get("status") or "",
-                "course_title": (row.get("proposed_json") or {}).get("course_title") or "",
-                "course_code": (row.get("proposed_json") or {}).get("course_code") or "",
-                "change_reason": row.get("change_reason") or "",
-                "created_at": row.get("created_at") or "",
-            }
-            for row in rows
-        ]
-    }
-
-
-@router.get("/agent/drafts/{draft_id}")
-def get_agent_draft(draft_id: int):
-    try:
-        return {"draft": load_agent_draft(draft_id)}
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-
-
-@router.get("/agent/drafts/{draft_id}/preview")
-def preview_agent_draft(draft_id: int):
-    try:
-        draft = load_agent_draft(draft_id)
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    html = templates.get_template("jinja_sample.html").render(course=draft["proposed_json"], curriculum_year=selected_curriculum_year(), asset_root="/")
-    return HTMLResponse(html, headers={"Cache-Control": "no-store"})
-
-
-@router.post("/agent/drafts/{draft_id}/apply")
-def apply_agent_draft(draft_id: int):
-    try:
-        draft = load_agent_draft(draft_id)
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-
-    summary = draft.get("diff_summary") or {}
-    if draft.get("status") != "proposed":
-        raise HTTPException(status_code=400, detail="Only proposed drafts can be applied")
-    if summary.get("protected_changes"):
-        raise HTTPException(status_code=400, detail="Draft changes deterministic fields")
-
-    try:
-        supabase.table("course_revision_history").insert(
-            {
-                "refined_id": draft["refined_id"],
-                "agent_draft_id": draft_id,
-                "previous_json": draft["base_refined_json"],
-                "next_json": draft["proposed_json"],
-                "json_patch": draft["json_patch"],
-                "diff_summary": summary,
-                "change_reason": draft.get("change_reason") or "",
-            }
-        ).execute()
-        data = update_refined_fields(int(draft["refined_id"]), draft["proposed_json"])
-        supabase.table("agent_drafts").update({"status": "applied"}).eq("id", draft_id).execute()
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"message": "Draft applied", "data": data}
-
-
-@router.post("/agent/document-drafts")
-def create_agent_document_draft(payload: AgentDocumentDraftPayload):
-    try:
-        records = [draft_record(course.refined_id, course.fields, payload.reason) for course in payload.courses]
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-
-    summaries = [record["diff_summary"] for record in records]
-    document_summary = {
-        "courses_changed": len(records),
-        "courses_with_removed_topics": sum(1 for summary in summaries if summary.get("topics_removed")),
-        "courses_with_protected_changes": sum(1 for summary in summaries if summary.get("protected_changes")),
-        "max_syllabus_change_percent": max((summary.get("syllabus_change_percent") or 0 for summary in summaries), default=0),
-    }
-    status = "blocked" if document_summary["courses_with_protected_changes"] else "proposed"
-
-    try:
-        document = (
-            supabase.table("agent_document_drafts")
-            .insert(
-                {
-                    "curriculum_version_id": payload.curriculum_version_id,
-                    "uploaded_document_id": payload.uploaded_document_id.strip(),
-                    "diff_summary": document_summary,
-                    "change_reason": payload.reason.strip(),
-                    "status": status,
-                }
-            )
-            .execute()
-            .data[0]
-        )
-        for record in records:
-            record["document_draft_id"] = document["id"]
-        drafts = supabase.table("agent_drafts").insert(records).execute().data
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"message": "Document draft created", "document_draft": document, "drafts": drafts}
-
-
-@router.get("/agent/document-drafts")
-def list_agent_document_drafts():
-    try:
-        rows = supabase.table("agent_document_drafts").select("*").order("id", desc=True).limit(100).execute().data
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {
-        "document_drafts": [
-            {
-                "id": row["id"],
-                "status": row.get("status") or "",
-                "uploaded_document_id": row.get("uploaded_document_id") or "",
-                "change_reason": row.get("change_reason") or "",
-                "created_at": row.get("created_at") or "",
-            }
-            for row in rows
-        ]
-    }
-
-
-@router.get("/agent/document-drafts/{document_draft_id}")
-def get_agent_document_draft(document_draft_id: int):
-    try:
-        return load_document_draft(document_draft_id)
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-
-
-@router.get("/agent/document-drafts/{document_draft_id}/preview")
-def preview_agent_document_draft(document_draft_id: int):
-    try:
-        drafts = load_document_draft(document_draft_id)["drafts"]
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    if not drafts:
-        raise HTTPException(status_code=404, detail="Document draft not found")
-
-    courses = sorted(
-        (draft["proposed_json"] for draft in drafts),
-        key=lambda course: (int(course.get("semester") or 0), str(course.get("course_code") or ""), str(course.get("course_title") or "")),
-    )
-    html = templates.get_template("jinja_sample.html").render(
-        courses=courses,
-        semester="",
-        curriculum_year=selected_curriculum_year(),
-        asset_root="/",
-        show_summaries=True,
-    )
-    return HTMLResponse(html, headers={"Cache-Control": "no-store"})
-
-
-@router.get("/agent/tools")
-def get_agent_tools():
-    return {"tools": list_tool_schemas()}
-
-
-@router.post("/agent/tools/{tool_name}")
-def run_agent_tool(tool_name: str, payload: AgentToolPayload):
-    try:
-        return {"name": tool_name, "result": call_tool(tool_name, payload.arguments)}
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc

backend/app/routes/chat.py

@@ -1,261 +0,0 @@
-import json
-import logging
-
-import sentry_sdk
-from fastapi import APIRouter, File, HTTPException, UploadFile
-from fastapi.responses import StreamingResponse
-from postgrest.exceptions import APIError
-
-from app.models.chat import ChatMessagePayload, ChatSessionPayload, ChatSessionTitlePayload
-from app.services.agent_tools import call_tool, list_tool_schemas
-from app.services.attachments import extract_text
-from app.services.curriculum import load_document_draft, refined_course
-from app.services.errors import database_http_exception
-from app.services.openrouter import OpenRouterError, stream_chat
-from app.supabase import first_row, supabase
-
-router = APIRouter()
-MAX_ATTACHMENT_CONTEXT = 12000
-logger = logging.getLogger(__name__)
-
-
-def load_chat_session(session_id: int) -> dict:
-    try:
-        row = first_row(supabase.table("chat_sessions").select("*").eq("id", session_id))
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    if not row:
-        raise HTTPException(status_code=404, detail="Chat session not found")
-    return row
-
-
-def chat_messages(session_id: int) -> list[dict]:
-    rows = supabase.table("chat_messages").select("*").eq("session_id", session_id).order("id").execute().data
-    return rows[-24:]
-
-
-def insert_chat_message(session_id: int, role: str, content: str, metadata: dict | None = None) -> dict:
-    return (
-        supabase.table("chat_messages")
-        .insert({"session_id": session_id, "role": role, "content": content, "metadata": metadata or {}})
-        .execute()
-        .data[0]
-    )
-
-
-def update_attachment_message(session_id: int, attachment_ids: list[int], message_id: int) -> None:
-    if attachment_ids:
-        supabase.table("chat_attachments").update({"message_id": message_id}).eq("session_id", session_id).in_("id", attachment_ids).execute()
-
-
-def attachment_ids(metadata: dict | None) -> list[int]:
-    ids = []
-    for item in (metadata or {}).get("attachments") or []:
-        if isinstance(item, dict) and item.get("id"):
-            ids.append(int(item["id"]))
-    return ids
-
-
-def attachment_context(session_id: int, metadata: dict | None) -> str:
-    ids = attachment_ids(metadata)
-    if not ids:
-        return ""
-    rows = supabase.table("chat_attachments").select("filename,status,error,extracted_text").eq("session_id", session_id).in_("id", ids).execute().data
-    blocks = []
-    for row in rows:
-        name = row.get("filename") or "attachment"
-        status = row.get("status") or ""
-        text = str(row.get("extracted_text") or "").strip()
-        if text:
-            blocks.append(f"Attachment: {name}\n{text[:MAX_ATTACHMENT_CONTEXT]}")
-        else:
-            error = row.get("error") or "No extracted text"
-            blocks.append(f"Attachment: {name}\nStatus: {status}. {error}")
-    return "\n\n".join(blocks)
-
-
-def stable_context(value: dict) -> str:
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2)[:12000]
-
-
-def chat_system_prompt(session: dict) -> str:
-    session_id = session.get("id")
-    context = ""
-    if session.get("refined_id"):
-        course = refined_course(int(session["refined_id"]))
-        context = stable_context({"active_session_id": session_id, "active_refined_id": session["refined_id"], "active_course": course})
-    elif session.get("document_draft_id"):
-        context = stable_context({"active_session_id": session_id, **load_document_draft(int(session["document_draft_id"]))})
-    else:
-        context = stable_context({"active_session_id": session_id})
-    return f"""You are the PESU Curriculum Automation live editor assistant.
-Be concise, practical, and specific to the active curriculum data.
-Always respond by calling a tool — never state limitations or guess. The available tools handle course data, fetching URLs, generating reports, and creating drafts.
-Read source documents with get_attachment_text, then call create_report to save generated content as a chat attachment.
-When the user asks to change the active course, call create_course_draft with the active_refined_id, only the fields that should change, and a short reason.
-When the user asks for changes across multiple courses or an uploaded document, inspect the curriculum or attachment text, then call create_document_draft with the affected courses.
-When the user asks what changed, call diff_course_json or read the relevant draft before answering.
-For broad document requests, use get_curriculum_json to inspect the whole syllabus before proposing edits.
-To fetch a public URL, call fetch_url and use the returned text.
-Never apply a draft, never claim a draft was applied, and never claim the refined database was changed.
-After creating a draft, tell the user to review the diff in the Review panel before applying it.
-After calling a tool, summarize the result for the user in natural language. Do not call another tool — stop and respond to the user.
-Do not change deterministic fields such as program, hours, credits, or course type.
-
-Active context:
-{context or "No active course or document draft is selected."}"""
-
-
-def model_messages(session_id: int, rows: list[dict]) -> list[dict]:
-    messages = []
-    for row in rows:
-        if row.get("role") not in {"user", "assistant"}:
-            continue
-        content = str(row.get("content") or "").strip()
-        context = attachment_context(session_id, row.get("metadata")) if row.get("role") == "user" else ""
-        if context:
-            content = f"{content}\n\n{context}".strip()
-        if content:
-            messages.append({"role": row["role"], "content": content})
-    return messages
-
-
-def sse(event: str, data: dict) -> str:
-    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
-
-
-@router.post("/chat/sessions")
-def create_chat_session(payload: ChatSessionPayload):
-    record = {"refined_id": payload.refined_id, "document_draft_id": payload.document_draft_id, "title": payload.title.strip()}
-    result = supabase.table("chat_sessions").insert(record).execute()
-    return {"session": result.data[0]}
-
-
-@router.get("/chat/sessions")
-def list_chat_sessions(refined_id: int | None = None, document_draft_id: int | None = None):
-    query = supabase.table("chat_sessions").select("*").eq("status", "active")
-    if refined_id is not None:
-        query = query.eq("refined_id", refined_id)
-    if document_draft_id is not None:
-        query = query.eq("document_draft_id", document_draft_id)
-    rows = query.order("id", desc=True).limit(50).execute().data
-    return {"sessions": rows}
-
-
-@router.get("/chat/sessions/{session_id}/messages")
-def get_chat_messages(session_id: int):
-    load_chat_session(session_id)
-    return {"messages": chat_messages(session_id)}
-
-
-@router.delete("/chat/sessions/{session_id}")
-def clear_chat_session(session_id: int):
-    load_chat_session(session_id)
-    supabase.table("chat_sessions").delete().eq("id", session_id).execute()
-    return {"message": "Chat deleted"}
-
-
-@router.patch("/chat/sessions/{session_id}")
-def rename_chat_session(session_id: int, payload: ChatSessionTitlePayload):
-    load_chat_session(session_id)
-    row = supabase.table("chat_sessions").update({"title": payload.title}).eq("id", session_id).execute().data[0]
-    return {"message": "Chat renamed", "session": row}
-
-
-@router.post("/chat/sessions/{session_id}/messages")
-def create_chat_message(session_id: int, payload: ChatMessagePayload):
-    if not payload.content and not payload.metadata:
-        raise HTTPException(status_code=400, detail="Message content is required")
-    session = load_chat_session(session_id)
-    user_message = insert_chat_message(session_id, "user", payload.content, payload.metadata)
-    update_attachment_message(session_id, attachment_ids(payload.metadata), user_message["id"])
-
-    def stream():
-        answer = []
-        tool_results = []
-
-        def remember_tool_result(name: str, result: dict) -> None:
-            tool_results.append({"name": name, "result": result})
-
-        def flush_tool_results():
-            while tool_results:
-                item = tool_results.pop(0)
-                draft = (item["result"] or {}).get("draft")
-                document_draft = (item["result"] or {}).get("document_draft")
-                if item["name"] == "create_course_draft" and draft:
-                    yield sse("draft", {"draft": draft})
-                if item["name"] == "create_document_draft" and document_draft:
-                    yield sse("document_draft", {"document_draft": document_draft})
-
-        try:
-            yield sse("status", {"message": "Message saved"})
-            rows = chat_messages(session_id)
-            yield sse("status", {"message": "Loading context"})
-            system = chat_system_prompt(session)
-            yield sse("status", {"message": "Streaming response"})
-            for item in stream_chat(system, model_messages(session_id, rows), list_tool_schemas(), call_tool, remember_tool_result):
-                if isinstance(item, dict) and "$status" in item:
-                    yield sse("status", {"message": item["$status"]})
-                    continue
-                yield from flush_tool_results()
-                answer.append(item)
-                yield sse("token", {"text": item})
-            yield from flush_tool_results()
-            message = insert_chat_message(session_id, "assistant", "".join(answer).strip())
-            yield sse("done", {"message_id": message["id"]})
-        except OpenRouterError as exc:
-            yield from flush_tool_results()
-            logger.warning(
-                "Chat model request failed for session %s: status=%s detail=%s",
-                session_id,
-                exc.status_code,
-                exc.provider_message[:300],
-            )
-            err = exc.message
-            if exc.provider_message:
-                err = f"{err} ({exc.provider_message[:200]})"
-            yield sse("error", {"message": err})
-        except Exception as exc:
-            yield from flush_tool_results()
-            logger.exception("Chat stream failed for session %s", session_id)
-            sentry_sdk.capture_exception(exc)
-            yield sse("error", {"message": "An internal error occurred. Please try again later."})
-
-    return StreamingResponse(stream(), media_type="text/event-stream", headers={"Cache-Control": "no-store"})
-
-
-@router.post("/chat/sessions/{session_id}/attachments")
-async def upload_chat_attachments(session_id: int, files: list[UploadFile] = File(...)):
-    load_chat_session(session_id)
-    attachments = []
-    for file in files:
-        data = await file.read()
-        text, status, error = extract_text(file.filename or "attachment", file.content_type or "", data)
-        row = (
-            supabase.table("chat_attachments")
-            .insert(
-                {
-                    "session_id": session_id,
-                    "filename": file.filename or "attachment",
-                    "content_type": file.content_type or "",
-                    "size_bytes": len(data),
-                    "extracted_text": text,
-                    "status": status,
-                    "error": error,
-                }
-            )
-            .execute()
-            .data[0]
-        )
-        attachments.append(
-            {
-                "id": row["id"],
-                "name": row["filename"],
-                "type": row["content_type"],
-                "size": row["size_bytes"],
-                "status": row["status"],
-                "error": row["error"],
-                "extracted_chars": len(row.get("extracted_text") or ""),
-            }
-        )
-    return {"attachments": attachments}

backend/app/routes/courses.py

@@ -1,33 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from postgrest.exceptions import APIError
-
-from app.preview import build_course_preview
-from app.services.curriculum import attach_submissions
-from app.services.errors import database_http_exception
-from app.supabase import first_row, supabase
-
-router = APIRouter()
-
-
-@router.get("/courses")
-def list_courses():
-    try:
-        rows = supabase.table("refined_submissions").select("*").neq("status", "archived").execute().data
-        rows = attach_submissions(rows)
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    courses = [build_course_preview(row) | {"id": row["id"]} for row in rows]
-    courses.sort(key=lambda item: (int(item.get("semester") or 0), item.get("course_code") or "", item.get("course_title") or ""))
-    return {"courses": courses}
-
-
-@router.delete("/courses/{refined_id}")
-def delete_course(refined_id: int):
-    try:
-        row = first_row(supabase.table("refined_submissions").select("id").eq("id", refined_id).neq("status", "archived"))
-        if not row:
-            raise HTTPException(status_code=404, detail="Course not found")
-        result = supabase.table("refined_submissions").update({"status": "archived"}).eq("id", refined_id).execute()
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"message": "Course removed", "course": result.data[0] if result.data else None}

backend/app/routes/health.py

@@ -1,18 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from postgrest.exceptions import APIError
-
-from app.services.errors import database_http_exception
-from app.services.schema import schema_status
-
-router = APIRouter()
-
-
-@router.get("/health/schema")
-def check_schema():
-    try:
-        status = schema_status()
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    if not status["ok"]:
-        raise HTTPException(status_code=503, detail=status)
-    return status

backend/app/routes/preview.py

@@ -1,76 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query
-from fastapi.responses import HTMLResponse, Response
-from weasyprint import HTML
-
-from app.preview import build_course_preview
-from app.rendering import FRONTEND_DIR, templates
-from app.services.curriculum import attach_submissions, ordered_courses, selected_curriculum_year
-from app.supabase import first_row, supabase
-
-router = APIRouter()
-
-
-@router.get("/preview/semester/{sem}/courses")
-def list_courses(sem: int):
-    result = supabase.table("refined_submissions").select("id").neq("status", "archived").eq("semester", sem).order("id").execute()
-    return {"course_ids": [row["id"] for row in result.data]}
-
-
-@router.get("/preview/courses")
-def list_all_courses():
-    result = supabase.table("refined_submissions").select("id,semester,course_code").neq("status", "archived").execute()
-    rows = sorted(result.data, key=lambda row: (int(row.get("semester") or 0), str(row.get("course_code") or ""), int(row.get("id") or 0)))
-    return {"course_ids": [row["id"] for row in rows]}
-
-
-@router.get("/preview/course/{refined_id}")
-def preview_course(refined_id: int, curriculum_year: str = Query("")):
-    row = first_row(supabase.table("refined_submissions").select("*").eq("id", refined_id))
-    if not row:
-        raise HTTPException(status_code=404, detail="Refined submission not found")
-    row = attach_submissions([row])[0]
-    html = templates.get_template("jinja_sample.html").render(
-        course=build_course_preview(row),
-        curriculum_year=selected_curriculum_year(curriculum_year),
-        asset_root="/",
-    )
-    return HTMLResponse(html, headers={"Cache-Control": "no-store"})
-
-
-@router.get("/preview/pdf")
-def download_all_pdf(download: bool = Query(False), curriculum_year: str = Query("")):
-    result = supabase.table("refined_submissions").select("*").neq("status", "archived").execute()
-    courses = ordered_courses(result.data)
-    html = templates.get_template("jinja_sample.html").render(
-        courses=courses,
-        semester="",
-        curriculum_year=selected_curriculum_year(curriculum_year),
-        asset_root="",
-        show_summaries=True,
-    )
-    pdf = HTML(string=html, base_url=str(FRONTEND_DIR)).write_pdf()
-    return pdf_response(pdf, "curriculum-preview.pdf", download)
-
-
-@router.get("/preview/semester/{sem}/pdf")
-def download_pdf(sem: int, download: bool = Query(False), curriculum_year: str = Query("")):
-    result = supabase.table("refined_submissions").select("*").neq("status", "archived").eq("semester", sem).order("id").execute()
-    courses = ordered_courses(result.data)
-    html = templates.get_template("jinja_sample.html").render(
-        courses=courses,
-        semester=sem,
-        curriculum_year=selected_curriculum_year(curriculum_year),
-        asset_root="",
-        show_summaries=True,
-    )
-    pdf = HTML(string=html, base_url=str(FRONTEND_DIR)).write_pdf()
-    return pdf_response(pdf, f"semester-{sem}.pdf", download)
-
-
-def pdf_response(pdf: bytes, filename: str, download: bool) -> Response:
-    disposition = "attachment" if download else "inline"
-    return Response(
-        content=pdf,
-        media_type="application/pdf",
-        headers={"Content-Disposition": f'{disposition}; filename="{filename}"', "Cache-Control": "no-store"},
-    )

backend/app/routes/refined.py

@@ -1,24 +0,0 @@
-from fastapi import APIRouter, HTTPException
-
-from app.preview import build_course_preview
-from app.services.curriculum import attach_submissions, update_refined_fields
-from app.supabase import first_row, supabase
-
-router = APIRouter()
-
-
-@router.get("/refined/{refined_id}")
-def get_refined(refined_id: int):
-    row = first_row(supabase.table("refined_submissions").select("*").eq("id", refined_id))
-    if not row:
-        raise HTTPException(status_code=404, detail="Refined submission not found")
-    row = attach_submissions([row])[0]
-    return {"id": refined_id, "fields": build_course_preview(row)}
-
-
-@router.patch("/refined/{refined_id}")
-def update_refined(refined_id: int, payload: dict):
-    fields = payload.get("fields")
-    if not isinstance(fields, dict):
-        raise HTTPException(status_code=400, detail="fields is required")
-    return {"message": "Updated", "data": update_refined_fields(refined_id, fields)}

backend/app/routes/submissions.py

@@ -1,41 +0,0 @@
-import sentry_sdk
-from fastapi import APIRouter, BackgroundTasks, HTTPException
-from postgrest.exceptions import APIError
-
-from app.models.submission import CourseSubmission
-from app.services.errors import database_http_exception
-from app.services.refinement import refine
-from app.supabase import supabase
-
-router = APIRouter()
-
-
-def refine_later(submission_id: int) -> None:
-    try:
-        refine(submission_id)
-    except Exception as exc:
-        sentry_sdk.capture_exception(exc)
-        supabase.table("submissions").update({"status": "refine_failed"}).eq("id", submission_id).execute()
-
-
-@router.post("/submissions")
-def receive(data: CourseSubmission, background_tasks: BackgroundTasks):
-    payload = data.model_dump()
-    payload["status"] = "pending"
-    try:
-        result = supabase.table("submissions").insert(payload).execute()
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    submission = result.data[0]
-    background_tasks.add_task(refine_later, submission["id"])
-    return {"message": "Submission Received!", "submission": submission}
-
-
-@router.post("/submissions/{id}/refine")
-def refine_submission(id: int):
-    try:
-        return {"message": "Refined", "data": refine(id)}
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except APIError as exc:
-        raise database_http_exception(exc) from exc

backend/app/routes/versions.py

@@ -1,198 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from fastapi.responses import HTMLResponse
-from postgrest.exceptions import APIError
-
-from app.preview import build_course_preview
-from app.rendering import templates
-from app.services.curriculum import attach_submissions, selected_curriculum_year, update_refined_fields
-from app.services.diffing import diff_course
-from app.services.errors import database_http_exception
-from app.supabase import first_row, supabase
-
-router = APIRouter()
-
-
-def _version(version_id: int) -> dict:
-    row = first_row(supabase.table("curriculum_versions").select("*").eq("id", version_id))
-    if not row:
-        raise HTTPException(status_code=404, detail="Version not found")
-    return row
-
-
-def _snapshot(version_id: int, refined_id: int) -> dict:
-    row = first_row(
-        supabase.table("finalized_submissions")
-        .select("*")
-        .eq("curriculum_version_id", version_id)
-        .eq("refined_id", refined_id)
-    )
-    if not row:
-        raise HTTPException(status_code=404, detail="Version course not found")
-    return row
-
-
-def _course_summary(row: dict) -> dict:
-    course = row.get("course_json") or {}
-    return {
-        "id": row["id"],
-        "refined_id": row["refined_id"],
-        "semester": course.get("semester") or "",
-        "course_code": course.get("course_code") or "",
-        "course_title": course.get("course_title") or "",
-    }
-
-
-@router.get("/versions")
-def list_versions():
-    try:
-        rows = supabase.table("curriculum_versions").select("*").order("id", desc=True).execute().data
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"versions": rows}
-
-
-@router.post("/versions")
-def create_version(payload: dict):
-    name = str(payload.get("name") or "").strip()
-    if not name:
-        raise HTTPException(status_code=400, detail="Version name is required")
-
-    try:
-        rows = supabase.table("refined_submissions").select("*").execute().data
-        rows = attach_submissions(rows)
-        courses = [{"refined_id": row["id"], "course_json": build_course_preview(row)} for row in rows]
-        version = (
-            supabase.table("curriculum_versions")
-            .insert(
-                {
-                    "name": name,
-                    "program": str(payload.get("program") or (courses[0]["course_json"].get("program") if courses else "") or "").strip(),
-                    "academic_year": selected_curriculum_year(payload.get("academic_year")),
-                    "status": str(payload.get("status") or "draft").strip(),
-                }
-            )
-            .execute()
-            .data[0]
-        )
-        if courses:
-            records = [{**course, "curriculum_version_id": version["id"]} for course in courses]
-            supabase.table("finalized_submissions").insert(records).execute()
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"version": version, "courses": len(courses)}
-
-
-@router.post("/versions/{version_id}/restore")
-def restore_version(version_id: int):
-    try:
-        version = _version(version_id)
-        rows = (
-            supabase.table("finalized_submissions")
-            .select("*")
-            .eq("curriculum_version_id", version_id)
-            .execute()
-            .data
-        )
-        version_refined_ids = [row["refined_id"] for row in rows]
-        current_rows = supabase.table("refined_submissions").select("*").execute().data
-        current = {row["id"]: build_course_preview(row) for row in attach_submissions(current_rows)}
-        current_status = {row["id"]: row.get("status") for row in current_rows}
-        extra_ids = [row["id"] for row in current_rows if row["id"] not in version_refined_ids]
-        history = []
-        restored = 0
-        for row in rows:
-            refined_id = int(row["refined_id"])
-            previous = current.get(refined_id)
-            restored_course = row["course_json"]
-            if not previous:
-                continue
-            if previous != restored_course:
-                summary = diff_course(previous, restored_course)
-                history.append(
-                    {
-                        "refined_id": refined_id,
-                        "source": "version_restore",
-                        "previous_json": previous,
-                        "next_json": restored_course,
-                        "json_patch": summary.pop("json_patch"),
-                        "diff_summary": summary,
-                        "change_reason": f"Restore version: {version['name']}",
-                    }
-                )
-            if previous != restored_course or current_status.get(refined_id) != "refined":
-                update_refined_fields(refined_id, {**restored_course, "status": "refined"})
-                restored += 1
-        if history:
-            supabase.table("course_revision_history").insert(history).execute()
-        if extra_ids:
-            supabase.table("refined_submissions").update({"status": "archived"}).in_("id", extra_ids).execute()
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"message": "Version restored", "version": version, "courses_restored": restored, "courses_archived": len(extra_ids)}
-
-
-@router.get("/versions/{version_id}")
-def get_version(version_id: int):
-    try:
-        version = _version(version_id)
-        rows = (
-            supabase.table("finalized_submissions")
-            .select("*")
-            .eq("curriculum_version_id", version_id)
-            .execute()
-            .data
-        )
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    courses = [_course_summary(row) for row in rows]
-    courses.sort(key=lambda course: (int(course.get("semester") or 0), str(course.get("course_code") or ""), str(course.get("course_title") or "")))
-    return {"version": version, "courses": courses}
-
-
-@router.get("/versions/{version_id}/courses/{refined_id}")
-def get_version_course(version_id: int, refined_id: int):
-    try:
-        version = _version(version_id)
-        snapshot = _snapshot(version_id, refined_id)
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    return {"version": version, "refined_id": refined_id, "fields": snapshot["course_json"]}
-
-
-@router.get("/versions/{version_id}/courses/{refined_id}/preview")
-def preview_version_course(version_id: int, refined_id: int):
-    try:
-        snapshot = _snapshot(version_id, refined_id)
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    version = _version(version_id)
-    html = templates.get_template("jinja_sample.html").render(course=snapshot["course_json"], curriculum_year=selected_curriculum_year(version.get("academic_year")), asset_root="/")
-    return HTMLResponse(html, headers={"Cache-Control": "no-store"})
-
-
-@router.get("/versions/{version_id}/preview")
-def preview_version(version_id: int):
-    try:
-        version = _version(version_id)
-        rows = (
-            supabase.table("finalized_submissions")
-            .select("*")
-            .eq("curriculum_version_id", version_id)
-            .order("refined_id")
-            .execute()
-            .data
-        )
-    except APIError as exc:
-        raise database_http_exception(exc) from exc
-    courses = sorted(
-        (row["course_json"] for row in rows),
-        key=lambda course: (int(course.get("semester") or 0), str(course.get("course_code") or ""), str(course.get("course_title") or "")),
-    )
-    html = templates.get_template("jinja_sample.html").render(
-        courses=courses,
-        semester="",
-        curriculum_year=selected_curriculum_year(version.get("academic_year")),
-        asset_root="/",
-        show_summaries=True,
-    )
-    return HTMLResponse(html, headers={"Cache-Control": "no-store"})

backend/app/services/agent_tools.py

@@ -1,319 +0,0 @@
-from collections.abc import Callable
-from dataclasses import dataclass
-
-import httpx
-
-from app.services.curriculum import draft_record, load_agent_draft, load_document_draft, ordered_courses, refined_course
-from app.services.diffing import diff_course
-from app.supabase import supabase
-
-ToolHandler = Callable[[dict], dict]
-
-
-@dataclass(frozen=True)
-class AgentTool:
-    name: str
-    description: str
-    parameters: dict
-    handler: ToolHandler
-
-    def schema(self) -> dict:
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": self.parameters,
-            },
-        }
-
-
-def list_tool_schemas() -> list[dict]:
-    return [tool.schema() for tool in TOOLS.values()]
-
-
-def call_tool(name: str, arguments: dict | None = None) -> dict:
-    tool = TOOLS.get(name)
-    if not tool:
-        raise LookupError("Agent tool not found")
-    return tool.handler(arguments or {})
-
-
-def _require_int(arguments: dict, key: str) -> int:
-    value = arguments.get(key)
-    if value is None:
-        raise ValueError(f"{key} is required")
-    return int(value)
-
-
-def _require_dict(arguments: dict, key: str) -> dict:
-    value = arguments.get(key)
-    if not isinstance(value, dict):
-        raise ValueError(f"{key} must be an object")
-    return value
-
-
-def _get_current_course(arguments: dict) -> dict:
-    return {"course": refined_course(_require_int(arguments, "refined_id"))}
-
-
-def _diff_course_json(arguments: dict) -> dict:
-    return diff_course(_require_dict(arguments, "current"), _require_dict(arguments, "proposed"))
-
-
-def _create_course_draft(arguments: dict) -> dict:
-    record = draft_record(
-        _require_int(arguments, "refined_id"),
-        _require_dict(arguments, "fields"),
-        str(arguments.get("reason") or ""),
-    )
-    draft = supabase.table("agent_drafts").insert(record).execute().data[0]
-    return {"draft": draft}
-
-
-def _get_curriculum_json(arguments: dict) -> dict:
-    query = supabase.table("refined_submissions").select("*").neq("status", "archived")
-    if arguments.get("semester") is not None:
-        query = query.eq("semester", int(arguments["semester"]))
-    return {"courses": ordered_courses(query.execute().data)}
-
-
-def _create_document_draft(arguments: dict) -> dict:
-    courses = arguments.get("courses")
-    if not isinstance(courses, list) or not courses:
-        raise ValueError("courses must be a non-empty array")
-
-    records = []
-    for course in courses:
-        if not isinstance(course, dict):
-            raise ValueError("each course must be an object")
-        records.append(draft_record(int(course.get("refined_id")), _require_dict(course, "fields"), str(arguments.get("reason") or "")))
-
-    summaries = [record["diff_summary"] for record in records]
-    document_summary = {
-        "courses_changed": len(records),
-        "courses_with_removed_topics": sum(1 for summary in summaries if summary.get("topics_removed")),
-        "courses_with_protected_changes": sum(1 for summary in summaries if summary.get("protected_changes")),
-        "max_syllabus_change_percent": max((summary.get("syllabus_change_percent") or 0 for summary in summaries), default=0),
-    }
-    document = (
-        supabase.table("agent_document_drafts")
-        .insert(
-            {
-                "curriculum_version_id": arguments.get("curriculum_version_id"),
-                "uploaded_document_id": str(arguments.get("uploaded_document_id") or "").strip(),
-                "diff_summary": document_summary,
-                "change_reason": str(arguments.get("reason") or "").strip(),
-                "status": "blocked" if document_summary["courses_with_protected_changes"] else "proposed",
-            }
-        )
-        .execute()
-        .data[0]
-    )
-    for record in records:
-        record["document_draft_id"] = document["id"]
-    drafts = supabase.table("agent_drafts").insert(records).execute().data
-    return {"document_draft": document, "drafts": drafts}
-
-
-def _get_course_draft(arguments: dict) -> dict:
-    return {"draft": load_agent_draft(_require_int(arguments, "draft_id"))}
-
-
-def _get_document_draft(arguments: dict) -> dict:
-    return load_document_draft(_require_int(arguments, "document_draft_id"))
-
-
-def _get_preview_url(arguments: dict) -> dict:
-    kind = str(arguments.get("kind") or "")
-    item_id = _require_int(arguments, "id")
-    paths = {
-        "course": f"/api/preview/course/{item_id}",
-        "draft": f"/api/agent/drafts/{item_id}/preview",
-        "document_draft": f"/api/agent/document-drafts/{item_id}/preview",
-    }
-    if kind not in paths:
-        raise ValueError("kind must be course, draft, or document_draft")
-    return {"url": paths[kind]}
-
-
-def _list_courses(arguments: dict) -> dict:
-    query = supabase.table("refined_submissions").select("id,semester,course_code,course_title").neq("status", "archived")
-    if arguments.get("semester") is not None:
-        query = query.eq("semester", int(arguments["semester"]))
-    rows = query.execute().data
-    rows.sort(key=lambda row: (int(row.get("semester") or 0), str(row.get("course_code") or ""), int(row.get("id") or 0)))
-    return {"courses": rows}
-
-
-def _fetch_url(arguments: dict) -> dict:
-    url = str(arguments.get("url") or "").strip()
-    if not url:
-        raise ValueError("url is required")
-    resp = httpx.get(url, timeout=30, follow_redirects=True)
-    resp.raise_for_status()
-    text = resp.text[:15000]
-    return {"url": url, "text": text, "chars": len(text)}
-
-
-def _create_report(arguments: dict) -> dict:
-    session_id = _require_int(arguments, "session_id")
-    content = str(arguments.get("content") or "").strip()
-    if not content:
-        raise ValueError("content is required")
-    filename = str(arguments.get("filename") or "report.md").strip()
-    row = (
-        supabase.table("chat_attachments")
-        .insert({
-            "session_id": session_id,
-            "filename": filename,
-            "content_type": "text/markdown",
-            "size_bytes": len(content.encode()),
-            "extracted_text": content,
-            "status": "ready",
-        })
-        .execute()
-        .data[0]
-    )
-    return {"attachment": {"id": row["id"], "filename": row["filename"], "chars": len(content)}}
-
-
-def _attachment_text(arguments: dict) -> dict:
-    session_id = _require_int(arguments, "session_id")
-    ids = [int(value) for value in arguments.get("attachment_ids") or []]
-    if not ids:
-        raise ValueError("attachment_ids is required")
-    rows = (
-        supabase.table("chat_attachments")
-        .select("id,filename,status,error,extracted_text")
-        .eq("session_id", session_id)
-        .in_("id", ids)
-        .execute()
-        .data
-    )
-    return {"attachments": rows}
-
-
-OBJECT = {"type": "object", "additionalProperties": False}
-
-TOOLS: dict[str, AgentTool] = {
-    "get_current_course_json": AgentTool(
-        "get_current_course_json",
-        "Read the current template-ready JSON for one refined course.",
-        {**OBJECT, "properties": {"refined_id": {"type": "integer"}}, "required": ["refined_id"]},
-        _get_current_course,
-    ),
-    "diff_course_json": AgentTool(
-        "diff_course_json",
-        "Compare two course JSON objects and return patch operations, changed percent, and syllabus topic changes.",
-        {**OBJECT, "properties": {"current": {"type": "object"}, "proposed": {"type": "object"}}, "required": ["current", "proposed"]},
-        _diff_course_json,
-    ),
-    "create_course_draft": AgentTool(
-        "create_course_draft",
-        "Create a human-reviewable draft for one course. This never applies changes to refined_submissions.",
-        {
-            **OBJECT,
-            "properties": {
-                "refined_id": {"type": "integer"},
-                "fields": {"type": "object"},
-                "reason": {"type": "string"},
-            },
-            "required": ["refined_id", "fields"],
-        },
-        _create_course_draft,
-    ),
-    "get_curriculum_json": AgentTool(
-        "get_curriculum_json",
-        "Read template-ready JSON for the full curriculum, optionally filtered by semester.",
-        {**OBJECT, "properties": {"semester": {"type": "integer", "minimum": 1, "maximum": 8}}},
-        _get_curriculum_json,
-    ),
-    "create_document_draft": AgentTool(
-        "create_document_draft",
-        "Create one human-reviewable document draft containing proposed changes for multiple courses. This never applies changes.",
-        {
-            **OBJECT,
-            "properties": {
-                "courses": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {"refined_id": {"type": "integer"}, "fields": {"type": "object"}},
-                        "required": ["refined_id", "fields"],
-                        "additionalProperties": False,
-                    },
-                },
-                "reason": {"type": "string"},
-                "uploaded_document_id": {"type": "string"},
-                "curriculum_version_id": {"type": "integer"},
-            },
-            "required": ["courses"],
-        },
-        _create_document_draft,
-    ),
-    "get_course_draft": AgentTool(
-        "get_course_draft",
-        "Read one staged course draft and its diff summary.",
-        {**OBJECT, "properties": {"draft_id": {"type": "integer"}}, "required": ["draft_id"]},
-        _get_course_draft,
-    ),
-    "get_document_draft": AgentTool(
-        "get_document_draft",
-        "Read one staged document draft and all linked course drafts.",
-        {**OBJECT, "properties": {"document_draft_id": {"type": "integer"}}, "required": ["document_draft_id"]},
-        _get_document_draft,
-    ),
-    "get_preview_url": AgentTool(
-        "get_preview_url",
-        "Return the preview URL for a course, course draft, or document draft.",
-        {
-            **OBJECT,
-            "properties": {
-                "kind": {"type": "string", "enum": ["course", "draft", "document_draft"]},
-                "id": {"type": "integer"},
-            },
-            "required": ["kind", "id"],
-        },
-        _get_preview_url,
-    ),
-    "list_courses": AgentTool(
-        "list_courses",
-        "List refined course IDs and titles, optionally filtered by semester.",
-        {**OBJECT, "properties": {"semester": {"type": "integer", "minimum": 1, "maximum": 8}}},
-        _list_courses,
-    ),
-    "get_attachment_text": AgentTool(
-        "get_attachment_text",
-        "Read extracted text for uploaded chat attachments within a chat session.",
-        {
-            **OBJECT,
-            "properties": {
-                "session_id": {"type": "integer"},
-                "attachment_ids": {"type": "array", "items": {"type": "integer"}},
-            },
-            "required": ["session_id", "attachment_ids"],
-        },
-        _attachment_text,
-    ),
-    "fetch_url": AgentTool(
-        "fetch_url",
-        "Fetch a public URL and return its text content. Use to read web pages, public documents, and online resources.",
-        {**OBJECT, "properties": {"url": {"type": "string"}}, "required": ["url"]},
-        _fetch_url,
-    ),
-    "create_report": AgentTool(
-        "create_report",
-        "Save a generated document (report, comparison, summary, etc.) as a chat attachment accessible to the user. Use after reading source documents and generating new content.",
-        {
-            **OBJECT,
-            "properties": {
-                "session_id": {"type": "integer"},
-                "content": {"type": "string", "description": "Full report/document content in markdown format"},
-                "filename": {"type": "string", "description": "Filename including extension, e.g. comparison-report.md"},
-            },
-            "required": ["session_id", "content"],
-        },
-        _create_report,
-    ),
-}

backend/app/services/attachments.py

@@ -1,91 +0,0 @@
-import re
-import subprocess
-import tempfile
-import zipfile
-from pathlib import Path
-from xml.etree import ElementTree
-
-MAX_FILE_BYTES = 8 * 1024 * 1024
-MAX_TEXT_CHARS = 50000
-SPACE = re.compile(r"[ \t]+")
-BLANKS = re.compile(r"\n{3,}")
-
-
-def extract_text(filename: str, content_type: str, data: bytes) -> tuple[str, str, str]:
-    if len(data) > MAX_FILE_BYTES:
-        return "", "failed", "File is larger than 8 MB"
-    suffix = Path(filename or "").suffix.lower()
-    try:
-        if suffix == ".pdf" or content_type == "application/pdf":
-            return _clean(_pdf_text(data)), "ready", ""
-        if suffix == ".docx":
-            return _clean(_docx_text(data)), "ready", ""
-        if suffix == ".xlsx":
-            return _clean(_xlsx_text(data)), "ready", ""
-        if suffix in {".txt", ".md", ".csv"} or content_type.startswith("text/"):
-            return _clean(_decode(data)), "ready", ""
-        if content_type.startswith("image/"):
-            return "", "unsupported", "Image OCR is not enabled yet"
-        return "", "unsupported", "File type is not supported yet"
-    except Exception as exc:
-        return "", "failed", str(exc)
-
-
-def _pdf_text(data: bytes) -> str:
-    with tempfile.TemporaryDirectory() as temp_dir:
-        path = Path(temp_dir) / "upload.pdf"
-        path.write_bytes(data)
-        result = subprocess.run(
-            ["pdftotext", "-layout", str(path), "-"],
-            check=True,
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        return result.stdout
-
-
-def _docx_text(data: bytes) -> str:
-    with tempfile.TemporaryDirectory() as temp_dir:
-        path = Path(temp_dir) / "upload.docx"
-        path.write_bytes(data)
-        with zipfile.ZipFile(path) as docx:
-            xml = docx.read("word/document.xml")
-    root = ElementTree.fromstring(xml)
-    ns = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
-    lines = []
-    for paragraph in root.iter(f"{ns}p"):
-        text = "".join(node.text or "" for node in paragraph.iter(f"{ns}t")).strip()
-        if text:
-            lines.append(text)
-    return "\n".join(lines)
-
-
-def _xlsx_text(data: bytes) -> str:
-    import openpyxl
-    with tempfile.TemporaryDirectory() as temp_dir:
-        path = Path(temp_dir) / "upload.xlsx"
-        path.write_bytes(data)
-        wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
-        rows = []
-        for sheet in wb:
-            for row in sheet.iter_rows(values_only=True):
-                line = "\t".join(str(c or "") for c in row)
-                if line.strip():
-                    rows.append(line)
-        return "\n".join(rows)
-
-
-def _decode(data: bytes) -> str:
-    for encoding in ("utf-8", "utf-16", "latin-1"):
-        try:
-            return data.decode(encoding)
-        except UnicodeDecodeError:
-            continue
-    return data.decode("utf-8", errors="ignore")
-
-
-def _clean(text: str) -> str:
-    text = SPACE.sub(" ", text.replace("\r\n", "\n").replace("\r", "\n"))
-    text = BLANKS.sub("\n\n", text).strip()
-    return text[:MAX_TEXT_CHARS]

backend/app/services/books.py

@@ -1,105 +0,0 @@
-import re
-
-WORD = re.compile(r"\w+")
-BOOK_STOP = re.compile(
-    r"\bCourse\b[\s\S]{0,160}\bOutcome\b|"
-    r"\b(Course\s+Objectives?|Assignment\s*/|Laboratory|Recommended\s+Materials)\b",
-    re.IGNORECASE,
-)
-BOOK_LABEL = re.compile(
-    r"(?im)^\s*(?:Text\s*)?Book\(s\):\s*|"
-    r"^\s*Text\s+Book\(s\):\s*|"
-    r"^\s*Reference\s*(?:Book\(s\):)?\s*"
-)
-BOOK_NUMBER = re.compile(r"(?:^|\n|\s{2,}|(?<=\.)\s+)\d+\s*[:.)]\s*")
-ORDINAL_LINE = re.compile(r"(?im)^\s*(st|nd|rd|th)\s*$")
-PAGE_NOISE = re.compile(
-    r"P\.?\s*E\.?\s*S\.?\s*University|"
-    r"Curriculum|"
-    r"\s*:-\s*[A-Za-z]*\s*\d{4}\s*-\s*\d{4}\b|"
-    r"\b\d+\s*\|\s*Page\b",
-    re.IGNORECASE,
-)
-TEXT_BOOK_LINE = re.compile(r"\bText\s+Book\(s\):", re.IGNORECASE)
-REFERENCE_LINE = re.compile(r"^\s*Reference\b", re.IGNORECASE)
-SECTION_END_LINE = re.compile(r"^\s*(Course\s+Outcome|Assignment\s*/|Course\s+Objectives?|Laboratory)\b", re.IGNORECASE)
-
-
-def _words(text: str) -> int:
-    return len(WORD.findall(text))
-
-
-def _flatten(values) -> str:
-    parts = []
-    for value in values:
-        if not value:
-            continue
-        if isinstance(value, list):
-            parts.extend(str(item) for item in value if str(item).strip())
-        else:
-            parts.append(str(value))
-    text = "\n".join(parts)
-    match = BOOK_STOP.search(text)
-    if match:
-        text = text[: match.start()]
-    text = ORDINAL_LINE.sub("", text)
-    text = PAGE_NOISE.sub("\n", text)
-    return BOOK_LABEL.sub("", text)
-
-
-def _clean(value: str) -> str:
-    value = BOOK_LABEL.sub("", value)
-    value = re.sub(r"\bBook\(s\):?\s*", "", value, flags=re.IGNORECASE)
-    value = re.sub(r"-\s+", "-", value)
-    return re.sub(r"\s+", " ", value).strip(" :")
-
-
-def parse_books(*values) -> list[str]:
-    text = _flatten(values)
-    if not text.strip():
-        return []
-
-    numbered = [part for part in BOOK_NUMBER.split(text) if part.strip()]
-    if numbered and (len(numbered) > 1 or BOOK_NUMBER.search(text)):
-        parts = numbered
-    else:
-        parts = [line for line in text.splitlines() if line.strip()]
-
-    books = []
-    seen = set()
-    for part in parts:
-        item = _clean(part)
-        if not item:
-            continue
-        if books and (item.startswith("(") or (_words(item) <= 3 and not re.search(r"\b\d{4}\b", item))):
-            books[-1] = f"{books[-1]} {item}".strip()
-            continue
-        key = re.sub(r"[^a-z0-9]+", " ", item.lower()).strip()
-        if key not in seen:
-            books.append(item)
-            seen.add(key)
-    return books
-
-
-def raw_book_section(raw_content: str, kind: str) -> str:
-    lines = (raw_content or "").splitlines()
-    start = None
-    for index, line in enumerate(lines):
-        if kind == "text" and TEXT_BOOK_LINE.search(line):
-            start = index
-            break
-        if kind == "reference" and REFERENCE_LINE.search(line):
-            start = index
-            break
-    if start is None:
-        return ""
-
-    end = len(lines)
-    for index in range(start + 1, len(lines)):
-        if kind == "text" and REFERENCE_LINE.search(lines[index]):
-            end = index
-            break
-        if SECTION_END_LINE.search(lines[index]):
-            end = index
-            break
-    return "\n".join(lines[start:end])

backend/app/services/curriculum.py

@@ -1,154 +0,0 @@
-from os import environ
-
-from app.preview import build_course_preview
-from app.services.diffing import diff_course, merge_fields, validate_draft
-from app.supabase import first_row, supabase
-
-DEFAULT_CURRICULUM_YEAR = environ.get("CURRICULUM_YEAR", "").strip()
-SOURCE_ORDER = {
-    "UE25CS151A": 1,
-    "UE25CS151B": 1,
-    "UE24CS251A": 1,
-    "UE24CS252A": 2,
-    "UE24MA242A": 3,
-    "UE24CS241A": 4,
-    "UE24CS243A": 5,
-    "UZ24UZ221A": 6,
-    "UE25MA201A*": 7,
-    "UE24CS251B": 1,
-    "UE24CS252B": 2,
-    "UE24CS241B": 3,
-    "UE24CS242B": 4,
-    "UE24MA241B": 5,
-    "UZ24UZ221B": 6,
-    "UE25MA201B*": 7,
-    "UE23CS351A": 1,
-    "UE23CS352A": 2,
-    "UE23CS341A": 3,
-    "UE23CS342AAX": 4,
-    "UE23CS343ABX": 5,
-    "UE23CS320A": 6,
-    "UE23CS351B": 1,
-    "UE23CS352B": 2,
-    "UE23CS341B": 3,
-    "UE23CS342BAX": 4,
-    "UE23CS343BBX": 5,
-    "UE23CS320B": 6,
-    "UE22CS441A": 1,
-    "UZ22UZ422A": 2,
-    "UE22AM421AXX": 3,
-    "UE22CS421B": 1,
-    "UE22CS461XB": 2,
-}
-
-REFINED_FIELDS = {
-    "semester",
-    "course_code",
-    "course_title",
-    "program",
-    "lecture_hours",
-    "tutorial_hours",
-    "practical_hours",
-    "self_study",
-    "credits",
-    "course_type",
-    "tools_languages",
-    "desirable_knowledge",
-    "prelude",
-    "objectives",
-    "course_outcomes",
-    "units",
-    "lab_experiments",
-    "text_books",
-    "reference_books",
-    "status",
-}
-
-
-def attach_submissions(rows: list[dict]) -> list[dict]:
-    ids = [row["submission_id"] for row in rows if row.get("submission_id")]
-    if not ids:
-        return rows
-    submissions = supabase.table("submissions").select("*").in_("id", ids).execute().data
-    by_id = {row["id"]: row for row in submissions}
-    for row in rows:
-        row["_submission"] = by_id.get(row.get("submission_id"), {})
-    return rows
-
-
-def ordered_courses(rows: list[dict]) -> list[dict]:
-    rows = attach_submissions(rows)
-    rows.sort(key=course_sort_key)
-    return [build_course_preview(row) for row in rows]
-
-
-def course_sort_key(row: dict) -> tuple[int, int, int]:
-    semester = int(row.get("semester") or 0)
-    code = str(row.get("course_code") or "").replace(" ", "").upper()
-    order = SOURCE_ORDER.get(code)
-    if order is None and semester == 5:
-        order = elective_order(code, "AA", "AB")
-    if order is None and semester == 6:
-        order = elective_order(code, "BA", "BB")
-    return semester, order or 900, int(row.get("id") or 0)
-
-
-def elective_order(code: str, first_group: str, second_group: str) -> int | None:
-    for offset, group in ((100, first_group), (200, second_group)):
-        if group in code:
-            suffix = code.rsplit(group, 1)[-1].rstrip("X")
-            return offset + int(suffix) if suffix.isdigit() else offset
-    return None
-
-
-def selected_curriculum_year(value: str | None = None) -> str:
-    return str(value or "").strip() or DEFAULT_CURRICULUM_YEAR
-
-
-def refined_course(refined_id: int) -> dict:
-    row = first_row(supabase.table("refined_submissions").select("*").eq("id", refined_id))
-    if not row:
-        raise LookupError("Refined submission not found")
-    return build_course_preview(attach_submissions([row])[0])
-
-
-def update_refined_fields(refined_id: int, fields: dict) -> dict | None:
-    update = {key: fields[key] for key in REFINED_FIELDS if key in fields}
-    for key in ("semester", "lecture_hours", "tutorial_hours", "practical_hours", "self_study", "credits"):
-        if key in update:
-            update[key] = int(update[key] or 0)
-    result = supabase.table("refined_submissions").update(update).eq("id", refined_id).execute()
-    return result.data[0] if result.data else None
-
-
-def draft_record(refined_id: int, fields: dict, reason: str = "", document_draft_id: int | None = None) -> dict:
-    base = refined_course(refined_id)
-    proposed = merge_fields(base, fields)
-    summary = diff_course(base, proposed)
-    issues = validate_draft(base, proposed)
-    summary["validation_issues"] = issues
-    return {
-        "refined_id": refined_id,
-        "document_draft_id": document_draft_id,
-        "base_refined_json": base,
-        "proposed_json": proposed,
-        "json_patch": summary.pop("json_patch"),
-        "diff_summary": summary,
-        "change_reason": reason.strip(),
-        "status": "blocked" if issues else "proposed",
-    }
-
-
-def load_agent_draft(draft_id: int) -> dict:
-    draft = first_row(supabase.table("agent_drafts").select("*").eq("id", draft_id))
-    if not draft:
-        raise LookupError("Agent draft not found")
-    return draft
-
-
-def load_document_draft(document_draft_id: int) -> dict:
-    document = first_row(supabase.table("agent_document_drafts").select("*").eq("id", document_draft_id))
-    if not document:
-        raise LookupError("Document draft not found")
-    drafts = supabase.table("agent_drafts").select("*").eq("document_draft_id", document_draft_id).order("id").execute().data
-    return {"document_draft": document, "drafts": drafts}

backend/app/services/deterministic.py

@@ -1,27 +0,0 @@
-def compute_hours(cat: str) -> dict:
-    return {
-        "5": {"lecture_hours": 4, "tutorial_hours": 0, "practical_hours": 2, "self_study": 5, "credits": 5},
-        "4": {"lecture_hours": 4, "tutorial_hours": 0, "practical_hours": 0, "self_study": 4, "credits": 4},
-        "2": {"lecture_hours": 2, "tutorial_hours": 0, "practical_hours": 0, "self_study": 2, "credits": 2},
-        "0": {"lecture_hours": 0, "tutorial_hours": 0, "practical_hours": 0, "self_study": 0, "credits": 0},
-    }[cat]
-
-
-def compute_program(dept: str) -> str:
-    return {
-        "CSE": "B. TECH",
-        "AIML": "B. TECH",
-        "ECE": "B. TECH",
-        "ME": "B. TECH",
-        "EEE": "B. TECH",
-        "BT": "B. TECH",
-    }[dept]
-
-
-def compute_course_type(cat: str) -> str:
-    return {
-        "0": "Foundation Course",
-        "5": "Core Course-Lab Integrated",
-        "4": "Core Course",
-        "2": "Core Theory",
-    }[cat]

backend/app/services/diffing.py

@@ -1,160 +0,0 @@
-import difflib
-import json
-import re
-from copy import deepcopy
-from typing import Any
-
-PROTECTED_FIELDS = {
-    "program",
-    "lecture_hours",
-    "tutorial_hours",
-    "practical_hours",
-    "self_study",
-    "credits",
-    "course_type",
-}
-
-TOPIC_SPLIT = re.compile(r"[,;\n]+")
-SPACE = re.compile(r"\s+")
-
-
-def stable_json(value: Any) -> str:
-    return json.dumps(value, indent=2, sort_keys=True, ensure_ascii=False)
-
-
-def build_patch(old: Any, new: Any, path: str = "") -> list[dict]:
-    if isinstance(old, dict) and isinstance(new, dict):
-        patch = []
-        old_keys = set(old)
-        new_keys = set(new)
-        for key in sorted(old_keys - new_keys):
-            patch.append({"op": "remove", "path": f"{path}/{_escape(key)}"})
-        for key in sorted(new_keys - old_keys):
-            patch.append({"op": "add", "path": f"{path}/{_escape(key)}", "value": new[key]})
-        for key in sorted(old_keys & new_keys):
-            patch.extend(build_patch(old[key], new[key], f"{path}/{_escape(key)}"))
-        return patch
-
-    if old != new:
-        return [{"op": "replace", "path": path or "/", "value": new}]
-    return []
-
-
-def apply_patch(value: Any, patch: list[dict]) -> Any:
-    result = deepcopy(value)
-    for op in patch:
-        name = op.get("op")
-        path = op.get("path")
-        if name not in {"add", "remove", "replace"} or not isinstance(path, str):
-            raise ValueError("Unsupported patch operation")
-        parent, key = _resolve_parent(result, path)
-        if isinstance(parent, list):
-            index = int(key)
-            if name == "remove":
-                parent.pop(index)
-            elif name == "replace":
-                parent[index] = op.get("value")
-            else:
-                parent.insert(index, op.get("value"))
-            continue
-        if name == "remove":
-            parent.pop(key, None)
-        else:
-            parent[key] = op.get("value")
-    return result
-
-
-def diff_course(old: dict, new: dict) -> dict:
-    old_text = stable_json(old)
-    new_text = stable_json(new)
-    patch = build_patch(old, new)
-    syllabus_old = _syllabus_text(old)
-    syllabus_new = _syllabus_text(new)
-    topics_old = _topics(syllabus_old)
-    topics_new = _topics(syllabus_new)
-
-    return {
-        "json_patch": patch,
-        "patch_operations": len(patch),
-        "change_percent": _change_percent(old_text, new_text),
-        "syllabus_change_percent": _change_percent(syllabus_old, syllabus_new),
-        "topics_added": sorted(topics_new - topics_old),
-        "topics_removed": sorted(topics_old - topics_new),
-        "protected_changes": sorted(field for field in PROTECTED_FIELDS if _field_value(old, field) != _field_value(new, field)),
-        "unified_diff": "\n".join(
-            difflib.unified_diff(
-                old_text.splitlines(),
-                new_text.splitlines(),
-                fromfile="current",
-                tofile="proposed",
-                lineterm="",
-            )
-        ),
-    }
-
-
-def validate_draft(old: dict, new: dict) -> list[str]:
-    issues = []
-    for field in PROTECTED_FIELDS:
-        if _field_value(old, field) != _field_value(new, field):
-            issues.append(f"{field} is deterministic and cannot be changed by an agent draft")
-    return issues
-
-
-def merge_fields(base: dict, fields: dict) -> dict:
-    merged = deepcopy(base)
-    for key, value in fields.items():
-        if key in PROTECTED_FIELDS and str(base.get(key) or "") == str(value or ""):
-            value = base.get(key)
-        merged[key] = value
-    return merged
-
-
-def _field_value(value: dict, field: str) -> str:
-    return str(value.get(field) or "")
-
-
-def _escape(value: str) -> str:
-    return value.replace("~", "~0").replace("/", "~1")
-
-
-def _unescape(value: str) -> str:
-    return value.replace("~1", "/").replace("~0", "~")
-
-
-def _resolve_parent(value: Any, path: str) -> tuple[Any, str]:
-    if path in {"", "/"}:
-        raise ValueError("Root patch operations are not supported")
-    parts = [_unescape(part) for part in path.strip("/").split("/")]
-    current = value
-    for part in parts[:-1]:
-        current = current[int(part)] if isinstance(current, list) else current[part]
-    return current, parts[-1]
-
-
-def _change_percent(old: str, new: str) -> float:
-    if not old and not new:
-        return 0.0
-    ratio = difflib.SequenceMatcher(None, old, new).ratio()
-    return round((1 - ratio) * 100, 2)
-
-
-def _syllabus_text(value: dict) -> str:
-    units = value.get("units") or []
-    if not isinstance(units, list):
-        return ""
-    parts = []
-    for unit in units:
-        if isinstance(unit, dict):
-            parts.append(str(unit.get("title") or ""))
-            parts.append(str(unit.get("content") or ""))
-    return SPACE.sub(" ", " ".join(parts)).strip()
-
-
-def _topics(text: str) -> set[str]:
-    topics = set()
-    for item in TOPIC_SPLIT.split(text):
-        topic = SPACE.sub(" ", item).strip(" .:-").lower()
-        if len(topic) >= 4:
-            topics.add(topic)
-    return topics

backend/app/services/errors.py

@@ -1,11 +0,0 @@
-import sentry_sdk
-from fastapi import HTTPException
-from postgrest.exceptions import APIError
-
-
-def database_http_exception(exc: APIError) -> HTTPException:
-    message = str(exc)
-    if "schema cache" in message and "Could not find the table" in message:
-        return HTTPException(status_code=503, detail="Required database tables are missing. Run docs/schema.sql in Supabase.")
-    sentry_sdk.capture_exception(exc)
-    return HTTPException(status_code=500, detail="Database request failed.")

backend/app/services/openrouter.py

@@ -1,221 +0,0 @@
-import json
-import logging
-import os
-
-from dotenv import load_dotenv
-from httpx import Client, HTTPError, HTTPStatusError
-
-load_dotenv("../.env")
-
-URL = os.environ["OPENROUTER_URL"].strip()
-KEY = os.environ["OPENROUTER_API_KEY"].strip()
-MODEL = os.environ["OPENROUTER_MODEL"].strip()
-logger = logging.getLogger(__name__)
-
-
-class OpenRouterError(RuntimeError):
-    def __init__(self, status_code: int, retry_after: str | None = None, message: str | None = None, provider_message: str = ""):
-        self.status_code = status_code
-        self.retry_after = retry_after
-        self._message = message
-        self.provider_message = provider_message
-        super().__init__(self.message)
-
-    @property
-    def message(self) -> str:
-        if self._message:
-            return self._message
-        if self.status_code in {429, 503}:
-            if self.retry_after:
-                return f"Model provider is rate limited. Try again in {self.retry_after} seconds."
-            return "Model provider is rate limited. Please try again shortly."
-        return "Model provider request failed. Please try again later."
-
-
-def _messages(system: str, messages: list[dict]) -> list[dict]:
-    return [{"role": "system", "content": system}, *messages]
-
-
-def _headers() -> dict:
-    return {"Authorization": f"Bearer {KEY}"}
-
-
-def _message_content(data: dict) -> str:
-    try:
-        return _assistant_message(data)["content"].strip()
-    except (KeyError, TypeError, AttributeError) as exc:
-        raise OpenRouterError(502, message="Model provider returned an invalid response. Please try again later.", provider_message=str(data.get("error") or data)[:500]) from exc
-
-
-def _raise_for_status(response) -> None:
-    try:
-        response.raise_for_status()
-    except HTTPStatusError as exc:
-        raise OpenRouterError(
-            exc.response.status_code,
-            exc.response.headers.get("retry-after"),
-            provider_message=exc.response.text[:500],
-        ) from exc
-
-
-def _provider_error(data: dict) -> str:
-    error = data.get("error") if isinstance(data, dict) else None
-    if isinstance(error, dict):
-        return str(error.get("message") or error)
-    return str(error or data)[:500]
-
-
-def _public_shape_error(provider_message: str) -> str:
-    lowered = provider_message.lower()
-    if "tool" in lowered and ("support" in lowered or "unsupported" in lowered):
-        return "The selected model does not support editor tools. Switch to a tool-calling model and try again."
-    if "rate" in lowered or "quota" in lowered:
-        return "Model provider is rate limited. Please try again shortly."
-    return "Model provider returned an invalid response. Please try again later."
-
-
-def _assistant_message(data: dict) -> dict:
-    try:
-        message = data["choices"][0]["message"]
-    except (KeyError, IndexError, TypeError) as exc:
-        provider_message = _provider_error(data)
-        raise OpenRouterError(502, message=_public_shape_error(provider_message), provider_message=provider_message) from exc
-    if not isinstance(message, dict):
-        raise OpenRouterError(502, message="Model provider returned an invalid response. Please try again later.", provider_message=str(message)[:500])
-    return message
-
-
-def call(system: str, user: str) -> dict:
-    with Client(timeout=120) as c:
-        r = c.post(
-            URL,
-            headers=_headers(),
-            json={"model": MODEL, "messages": _messages(system, [{"role": "user", "content": user}])},
-        )
-        _raise_for_status(r)
-        data = r.json()
-        text = _message_content(data)
-        text = text.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
-        return json.loads(text)
-
-
-def stream_chat(system: str, messages: list[dict], tools: list[dict] | None = None, tool_runner=None, on_tool_result=None):
-    chat_messages = _messages(system, messages)
-    if tools and tool_runner:
-        yield from _chat_with_tools(chat_messages, tools, tool_runner, on_tool_result)
-        return
-
-    emitted = False
-    try:
-        for token in _stream_chat(chat_messages):
-            emitted = True
-            yield token
-    except (HTTPError, json.JSONDecodeError) as exc:
-        _log_stream_fallback(exc)
-
-    if emitted:
-        return
-
-    text = _chat_text(chat_messages)
-    if text:
-        yield text
-
-
-def _stream_chat(messages: list[dict]):
-    payload = {"model": MODEL, "messages": messages, "stream": True}
-    with Client(timeout=120) as client:
-        with client.stream("POST", URL, headers=_headers(), json=payload) as response:
-            if response.is_error:
-                response.read()
-            response.raise_for_status()
-            for line in response.iter_lines():
-                token = _stream_token(line)
-                if token:
-                    yield token
-
-
-def _chat_text(messages: list[dict]) -> str:
-    with Client(timeout=120) as client:
-        response = client.post(URL, headers=_headers(), json={"model": MODEL, "messages": messages})
-        _raise_for_status(response)
-        return _message_content(response.json())
-
-
-def _chat_message(messages: list[dict], tools: list[dict]) -> dict:
-    with Client(timeout=120) as client:
-        response = client.post(URL, headers=_headers(), json={"model": MODEL, "messages": messages, "tools": tools})
-        _raise_for_status(response)
-        return _assistant_message(response.json())
-
-
-def _chat_with_tools(messages: list[dict], tools: list[dict], tool_runner, on_tool_result=None):
-    for _ in range(5):
-        yield {"$status": f"Thinking... (attempt {_ + 1}/5)"}
-        message = _chat_message(messages, tools)
-        tool_calls = message.get("tool_calls") or []
-        if not tool_calls:
-            text = str(message.get("content") or "").strip()
-            if text:
-                yield text
-            return
-
-        messages.append({"role": "assistant", "content": message.get("content") or "", "tool_calls": tool_calls})
-        for tool_call in tool_calls:
-            name = (tool_call.get("function") or {}).get("name") or ""
-            try:
-                result = _run_tool(tool_runner, name, _tool_arguments(tool_call))
-            except ValueError as exc:
-                result = {"error": str(exc)}
-            if on_tool_result:
-                on_tool_result(name, result)
-            messages.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": tool_call.get("id") or name,
-                    "name": name,
-                    "content": json.dumps(result, ensure_ascii=False),
-                }
-            )
-    yield "I created tool results, but could not finish the response. Please check the Review panel."
-
-
-def _tool_arguments(tool_call: dict) -> dict:
-    raw = (tool_call.get("function") or {}).get("arguments") or "{}"
-    arguments = json.loads(raw) if isinstance(raw, str) else raw
-    if not isinstance(arguments, dict):
-        raise ValueError("Tool arguments must be an object")
-    return arguments
-
-
-def _run_tool(tool_runner, name: str, arguments: dict) -> dict:
-    try:
-        return tool_runner(name, arguments)
-    except Exception as exc:
-        return {"error": str(exc)}
-
-
-def _log_stream_fallback(exc: Exception) -> None:
-    if isinstance(exc, HTTPStatusError):
-        response = exc.response
-        logger.warning(
-            "OpenRouter streaming failed; retrying without stream. status=%s model=%s body=%s",
-            response.status_code,
-            MODEL,
-            response.text[:500],
-        )
-        return
-    logger.warning("OpenRouter streaming failed; retrying without stream. error=%s model=%s", exc.__class__.__name__, MODEL)
-
-
-def _stream_token(line: str) -> str:
-    if not line or line.startswith(":"):
-        return ""
-    if not line.startswith("data:"):
-        return ""
-    data = line.removeprefix("data:").strip()
-    if data == "[DONE]":
-        return ""
-    chunk = json.loads(data)
-    choice = (chunk.get("choices") or [{}])[0]
-    delta = choice.get("delta") or {}
-    return delta.get("content") or ""

backend/app/services/refinement.py

@@ -1,491 +0,0 @@
-import re
-
-from app.supabase import first_row, supabase
-from app.services.books import parse_books, raw_book_section
-from app.services.deterministic import compute_hours, compute_program, compute_course_type
-from app.services.openrouter import call as llm
-
-WORD = re.compile(r"\w+")
-UNIT_LINE = re.compile(r"\b(Unit\s+\d+|Module\s+(?:\d+|[IVX]+))\s*[:.-]?\s*(.*)$", re.IGNORECASE)
-HOURS_SUFFIX = re.compile(r"\s*\b\d+\s+Hours?\b\s*$", re.IGNORECASE)
-DESIRABLE_LINE = re.compile(r"\bDesirable\s+([^\n]+)", re.IGNORECASE)
-COURSE_CODE = re.compile(r"\bCourse\s+Code\s*:?\s*([A-Z0-9]+)", re.IGNORECASE)
-PAGE_NOISE = re.compile(
-    r"P\.?\s*E\.?\s*S\.?\s*University|"
-    r"Curriculum|"
-    r"\s*:-\s*[A-Za-z]*\s*\d{4}\s*-\s*\d{4}\b|"
-    r"\b\d+\s*\|\s*Page\b",
-    re.IGNORECASE,
-)
-
-SYS = """You refine PES University course submissions for the UG curriculum template.
-Return only valid JSON. No markdown. No commentary.
-Priority order:
-1. Preserve the submitted academic content.
-2. Correct spelling, grammar, casing, and formatting.
-3. Fill missing template fields from the submitted course scope.
-4. Return the required JSON shape.
-
-Editing rules:
-- Refine, do not rewrite. If the input is already curriculum-ready, keep its wording and structure except for small correctness fixes.
-- If prelude, objectives, outcomes, units, tools, or books are already present, clean them instead of replacing them.
-- Generate a field only when that field is missing, incomplete, or too rough for the template.
-- Preserve every syllabus topic and subtopic from Raw Course Content.
-- Do not summarize away, omit, replace, merge away, or simplify syllabus topics.
-- Do not add advanced, fashionable, or unrelated topics.
-- Do not invent course codes, books, references, departments, credits, or external prerequisites.
-- Correct course title typos, casing, spacing, and grammar.
-- Keep objectives and outcomes direct, concise, and aligned with the submitted scope.
-- Return exactly 4 units. If the input already has 4 units, keep those boundaries. If it has a different structure, redistribute topics in order without dropping content.
-- Unit hours must sum to the supplied total unit hours.
-- For tools/languages, use Preferred Tools / Languages when provided; otherwise identify course-specific tools, languages, platforms, or AI tools from Raw Course Content.
-- Do not use canned defaults for tools/languages.
-- For desirable knowledge, use only relevant knowledge from Previously Completed Courses. Return an empty string when none apply.
-- Generate laboratory experiments only when practical hours are non-zero. Keep them tied to submitted topics.
-- Copy and clean books from the submitted book fields only.
-- Use empty strings or empty arrays for truly unavailable optional content. Do not output "-".
-"""
-
-SCHEMA = """{
-  "course_title": "corrected course title",
-  "prelude": "one short paragraph",
-  "objectives": ["3 to 4 objectives"],
-  "course_outcomes": ["3 to 4 measurable outcomes"],
-  "units": [{"title": "Unit 1: Title", "content": "compact topic list", "hours": 14}],
-  "lab_experiments": ["concise lab item"],
-  "tools_languages": "course-specific tools, languages, platforms, or AI tools",
-  "desirable_knowledge": "short text based only on previously completed courses, or empty string",
-  "text_books": ["submitted text books only"],
-  "reference_books": ["submitted reference books only"]
-}"""
-
-EXAMPLES = """Behavior examples calibrated to PESU curriculum style.
-Use them only to learn fidelity, field shape, and level of detail. Do not copy example facts into the real answer.
-
-Example 1: already refined input
-Input:
-Course Title: Web Technologies
-Weekly Hours: L 4, T 0, P 0, S 4, C 4
-Total Unit Hours: 56
-Raw Course Content:
-Unit 1: HTML, CSS and Client-Side Scripting - web architecture, HTTP request and response formats, URLs, HTML elements and attributes, web forms, HTML5 tags and controls, CSS selectors, style properties, box model, JavaScript objects, DOM manipulation, events and event handling. 14 Hours
-Unit 2: HTML5 and ReactJS - HTML5 APIs, audio, video, progress, geolocation, callbacks, promises, single page applications, XML vs JSON, async/await, JSX, rendering elements, React setup, components, styling, props, state and context. 14 Hours
-Unit 3: ReactJS and NodeJS - complex state management, keys, event handling, forms, hooks including useState, useRef, useEffect, useContext and useReducer, React Router, introduction to NextJS, NodeJS architecture, callbacks, modules, buffers, streams, file system and Axios API. 14 Hours
-Unit 4: MongoDB and ExpressJS - documents, collections, reading and writing to MongoDB, MongoDB NodeJS driver, running a React application on NodeJS, React Router, web services, REST APIs, Express routing, URL building, error handling, middleware, form data and file upload. 14 Hours
-Preferred Tools / Languages: HTML, CSS, JavaScript, MERN Technologies, GitHub, AI tools: Copilot and Tabnine
-Previously Completed Courses: None
-Text Books:
-1. Robin Nixon, Learning PHP, MySQL and JavaScript, 5th Edition, O'Reilly Media, 2018.
-2. Vasan Subramanian, Pro MERN Stack: Full Stack Web App Development with Mongo, Express, React, and Node, Apress, 2017.
-Output:
-{
-  "course_title": "Web Technologies",
-  "prelude": "This course develops an in-depth understanding of technologies required to design and develop rich web applications using client-side scripting, ReactJS, NodeJS, ExpressJS, and MongoDB.",
-  "objectives": ["Build web pages using HTML, CSS, JavaScript, and advanced JavaScript concepts.", "Use HTML5, AJAX, JSON, and ReactJS to develop interactive user interfaces.", "Build multi-tier applications by connecting ReactJS interfaces to NodeJS services.", "Integrate MongoDB through ExpressJS and RESTful web services."],
-  "course_outcomes": ["Develop web pages using HTML, CSS, JavaScript, DOM manipulation, and event handling.", "Create interactive user interfaces using HTML5 APIs and ReactJS components.", "Implement server-side functionality using NodeJS, modules, streams, file system APIs, and routing.", "Create RESTful services with ExpressJS and integrate MongoDB for persistent storage."],
-  "units": [
-    {"title": "Unit 1: HTML, CSS and Client-Side Scripting", "content": "Web architecture, HTTP request and response formats, URLs, HTML elements and attributes, web forms, HTML5 tags and controls, CSS selectors, style properties, box model, JavaScript objects, DOM manipulation, events and event handling.", "hours": 14},
-    {"title": "Unit 2: HTML5 and ReactJS", "content": "HTML5 APIs, audio, video, progress, geolocation, callbacks, promises, single page applications, XML vs JSON, async/await, JSX, rendering elements, React setup, components, styling, props, state and context.", "hours": 14},
-    {"title": "Unit 3: ReactJS and NodeJS", "content": "Complex state management, keys, event handling, forms, hooks including useState, useRef, useEffect, useContext and useReducer, React Router, introduction to NextJS, NodeJS architecture, callbacks, modules, buffers, streams, file system and Axios API.", "hours": 14},
-    {"title": "Unit 4: MongoDB and ExpressJS", "content": "Documents, collections, reading and writing to MongoDB, MongoDB NodeJS driver, running a React application on NodeJS, React Router, web services, REST APIs, Express routing, URL building, error handling, middleware, form data and file upload.", "hours": 14}
-  ],
-  "lab_experiments": [],
-  "tools_languages": "HTML, CSS, JavaScript, MERN Technologies, GitHub; AI tools: Copilot, Tabnine",
-  "desirable_knowledge": "",
-  "text_books": ["Robin Nixon, Learning PHP, MySQL and JavaScript, 5th Edition, O'Reilly Media, 2018.", "Vasan Subramanian, Pro MERN Stack: Full Stack Web App Development with Mongo, Express, React, and Node, Apress, 2017."],
-  "reference_books": []
-}
-
-Example 2: detailed lab-integrated input with title and formatting issues
-Input:
-Course Title: data structures & its aplications
-Weekly Hours: L 4, T 0, P 2, S 5, C 5
-Total Unit Hours: 56
-Raw Course Content:
-Unit 1: Linked List and Stacks - Review of C, static and dynamic memory allocation, doubly linked list, circular linked list, multilist and sparse matrix, skip list dictionary case study, stack using arrays and linked list, function execution, nested functions, recursion, Tower of Hanoi, infix to postfix, infix to prefix, expression evaluation, matching parenthesis. 14 Hours
-Unit 2: Queues and Trees - simple queue, circular queue, priority queue, dequeue using arrays and linked list, Josephus problem, CPU scheduling using queues, N-ary trees, binary trees, binary search trees, forests, conversion to binary tree, preorder, inorder and postorder traversal. 14 Hours
-Unit 3: Application of Trees and Introduction to Graphs - BST insertion and deletion using arrays and dynamic allocation, binary expression tree, threaded binary search tree, heaps, priority queue using min heap and max heap, dictionary and decision tree applications, AVL trees, rotations, splay tree, graph properties, adjacency matrix, adjacency list, DFS, BFS, network topology representation. 14 Hours
-Unit 4: Applications of Graphs, B-Trees, Suffix Tree and Hashing - BFS and DFS applications, connectivity, path finding in a network, suffix trees, trie trees, insert, delete and search operations, hashing, hash functions, hash tables, separate chaining, open addressing, double hashing, rehashing, URL decoding and word prediction using trie trees and suffix trees. 14 Hours
-Laboratory: linked list operations; stack applications; queue applications; binary tree and BST applications; graph data structure applications; hashing techniques.
-Preferred Tools / Languages: C-Programming language; AI tools: VisuAlgo (Interactive Visualizations), Algorithm Visualizer (AI Explanations)
-Previously Completed Courses: Problem Solving with C
-Text Books: 1. Langsam Yedidyah, Moshe J. Augenstein, Aaron M. Tenenbaum, Data Structures using C / C++, Pearson Education Inc., 2nd Edition, 2015.
-Output:
-{
-  "course_title": "Data Structures and Applications",
-  "prelude": "This course introduces fundamental data structure concepts with emphasis on their theoretical foundations, implementation techniques, and practical applications using a programming language.",
-  "objectives": ["Analyze and design data structures for efficient storage, retrieval, and manipulation.", "Use linked lists, stacks, queues, trees, heaps, and graphs for suitable computational tasks.", "Implement insertion, deletion, searching, and modification operations across linear and non-linear data structures.", "Select and apply appropriate data structures to solve application-oriented problems."],
-  "course_outcomes": ["Select and apply appropriate data structures for solving problems across application domains.", "Implement fundamental data structures and their operations using suitable programming constructs.", "Use data structures effectively to design efficient solutions for computational problems.", "Develop software components by applying data structure principles and their applications."],
-  "units": [
-    {"title": "Unit 1: Linked List and Stacks", "content": "Review of C, static and dynamic memory allocation, doubly linked list, circular linked list, multilist and sparse matrix, skip list dictionary case study, stack using arrays and linked list, function execution, nested functions, recursion, Tower of Hanoi, infix to postfix, infix to prefix, expression evaluation, matching parenthesis.", "hours": 14},
-    {"title": "Unit 2: Queues and Trees", "content": "Simple queue, circular queue, priority queue, dequeue using arrays and linked list, Josephus problem, CPU scheduling using queues, N-ary trees, binary trees, binary search trees, forests, conversion to binary tree, preorder, inorder and postorder traversal.", "hours": 14},
-    {"title": "Unit 3: Application of Trees and Introduction to Graphs", "content": "BST insertion and deletion using arrays and dynamic allocation, binary expression tree, threaded binary search tree, heaps, priority queue using min heap and max heap, dictionary and decision tree applications, AVL trees, rotations, splay tree, graph properties, adjacency matrix, adjacency list, DFS, BFS, network topology representation.", "hours": 14},
-    {"title": "Unit 4: Applications of Graphs, B-Trees, Suffix Tree and Hashing", "content": "BFS and DFS applications, connectivity, path finding in a network, suffix trees, trie trees, insert, delete and search operations, hashing, hash functions, hash tables, separate chaining, open addressing, double hashing, rehashing, URL decoding and word prediction using trie trees and suffix trees.", "hours": 14}
-  ],
-  "lab_experiments": ["Linked list and advanced operations.", "Stack applications.", "Queue applications.", "Binary tree and binary search tree applications.", "Graph data structure applications.", "Hashing techniques."],
-  "tools_languages": "C-Programming language; AI tools: VisuAlgo (Interactive Visualizations), Algorithm Visualizer (AI Explanations)",
-  "desirable_knowledge": "Problem Solving with C",
-  "text_books": ["Langsam Yedidyah, Moshe J. Augenstein, Aaron M. Tenenbaum, Data Structures using C / C++, Pearson Education Inc., 2nd Edition, 2015."],
-  "reference_books": []
-}
-"""
-
-
-def _lines(value) -> list[str]:
-    if not value:
-        return []
-    if isinstance(value, list):
-        return [str(item).strip() for item in value if str(item).strip()]
-    return [line.strip() for line in str(value).splitlines() if line.strip()]
-
-
-def _clean_noise(value: str) -> str:
-    return re.sub(r"\s+", " ", PAGE_NOISE.sub(" ", value)).strip()
-
-
-def _books(*values) -> list[str]:
-    return parse_books(*values)
-
-
-def _raw_book_section(raw_content: str, kind: str) -> str:
-    return raw_book_section(raw_content, kind)
-
-
-def _words(text: str) -> int:
-    return len(WORD.findall(text))
-
-
-def _clean_part(value: str) -> str:
-    return _clean_noise(value.strip(" \t-*\u2022"))
-
-
-def _split_parts(text: str) -> list[str]:
-    lines = [_clean_part(line) for line in text.splitlines() if _clean_part(line)]
-    if len(lines) >= 4:
-        return lines
-    compact = _clean_part(text)
-    parts = [_clean_part(part) for part in re.split(r"(?<=[.!?])\s+", compact) if _clean_part(part)]
-    if len(parts) >= 4:
-        return parts
-    words = compact.split()
-    if not words:
-        return []
-    return [
-        " ".join(words[(index * len(words)) // 4 : ((index + 1) * len(words)) // 4])
-        for index in range(4)
-    ]
-
-
-def _four_units_from_raw(raw_content: str) -> list[dict]:
-    parts = _split_parts(raw_content)
-    if not parts:
-        return []
-    buckets = [[] for _ in range(4)]
-    for index, part in enumerate(parts):
-        buckets[min(index * 4 // len(parts), 3)].append(part)
-    return [
-        {"title": f"Unit {index + 1}", "content": " ".join(bucket).strip(), "hours": 0}
-        for index, bucket in enumerate(buckets)
-        if bucket
-    ]
-
-
-def _course_contents(raw_content: str) -> str:
-    lines = raw_content.splitlines()
-    start = None
-    for index, line in enumerate(lines):
-        if "Course" in line and "Contents" in line:
-            start = index
-            break
-        if "Course" in line and any("Contents" in item for item in lines[index + 1 : index + 3]):
-            start = index
-            break
-    if start is None:
-        return raw_content
-
-    end = len(lines)
-    for index in range(start + 1, len(lines)):
-        marker = lines[index].strip()
-        if not marker:
-            continue
-        if any(marker.startswith(label) for label in ("Laboratory", "Text Book", "Reference", "Course Outcome", "Assignment /")):
-            end = index
-            break
-    return "\n".join(lines[start:end]).strip()
-
-
-def _syllabus_line(line: str) -> str:
-    clean = _clean_part(line)
-    clean = re.sub(r"^(Course\s+Contents|Contents)\s+", "", clean, flags=re.IGNORECASE)
-    clean = re.sub(r"^Course\s+(?=Unit\s+\d+|Module\s+(?:\d+|[IVX]+))", "", clean, flags=re.IGNORECASE)
-    return HOURS_SUFFIX.sub("", clean).strip()
-
-
-def _units_from_course_contents(raw_content: str, fallback: bool = True) -> list[dict]:
-    content = _course_contents(raw_content)
-    lines = [line.strip() for line in content.splitlines() if line.strip()]
-    units = []
-    current = None
-
-    for line in lines:
-        clean = _syllabus_line(line)
-        if not clean:
-            continue
-        match = UNIT_LINE.search(clean)
-        if match:
-            if current:
-                units.append(current)
-            label = match.group(1).strip().title()
-            rest = match.group(2).strip(" :-")
-            if " - " in rest:
-                title, inline_content = rest.split(" - ", 1)
-            elif _words(rest) > 12:
-                title, inline_content = "", rest
-            else:
-                title, inline_content = rest, ""
-            current = {
-                "title": f"{label}: {title.strip()}" if title.strip() else label,
-                "content": inline_content.strip(),
-                "hours": 0,
-            }
-            continue
-        if current:
-            current["content"] = f"{current['content']} {clean}".strip()
-
-    if current:
-        units.append(current)
-    if len(units) == 4:
-        return units
-    return _four_units_from_raw(content) if fallback else []
-
-
-def _unit_text(unit: dict) -> str:
-    title = str(unit.get("title", "")).strip()
-    content = str(unit.get("content", "")).strip()
-    if title and content:
-        return f"{title}: {content}"
-    return title or content
-
-
-def _fit_four_units(units: list[dict], raw_content: str) -> list[dict]:
-    raw = _course_contents(raw_content).strip()
-    raw_units = _units_from_course_contents(raw_content, fallback=False)
-    raw_unit_words = _words(" ".join(_unit_text(unit) for unit in raw_units))
-    if raw_units and raw_unit_words >= _words(raw) * 0.7:
-        return raw_units
-    if raw and _words(" ".join(_unit_text(unit) for unit in units)) < _words(raw) * 0.8:
-        return raw_units or _units_from_course_contents(raw_content)
-    if len(units) > 4:
-        fourth = units[3].copy()
-        fourth["content"] = " ".join(_unit_text(unit) for unit in units[3:]).strip()
-        return units[:3] + [fourth]
-    if len(units) == 4:
-        return units
-    if raw:
-        return raw_units or _units_from_course_contents(raw_content)
-    return units
-
-
-def _units(value) -> list[dict]:
-    units = []
-    for item in value if isinstance(value, list) else []:
-        if not isinstance(item, dict):
-            continue
-        title = str(item.get("title", "")).strip()
-        content = str(item.get("content", "")).strip()
-        hours_raw = str(item.get("hours", "0"))
-        hours = int("".join(ch for ch in hours_raw if ch.isdigit()) or 0)
-        if title or content:
-            units.append({"title": title, "content": content, "hours": hours})
-    return units
-
-
-def _assign_hours(units: list[dict], total_hours: int) -> list[dict]:
-    if not units:
-        return units
-    if sum(unit["hours"] for unit in units) == total_hours:
-        return units
-    base, extra = divmod(total_hours, len(units))
-    for index, unit in enumerate(units):
-        unit["hours"] = base + (1 if index < extra else 0)
-    return units
-
-
-def _text(*values) -> str:
-    for value in values:
-        if isinstance(value, str):
-            text = value.strip()
-            if text and text != "-":
-                return text
-    return ""
-
-
-def _course_code(raw_content: str) -> str:
-    match = COURSE_CODE.search(raw_content or "")
-    return match.group(1).upper() if match else ""
-
-
-def _prior_course_titles(sub: dict) -> list[str]:
-    semester = int(sub["semester"])
-    if semester <= 1:
-        return []
-    rows = (
-        supabase.table("refined_submissions")
-        .select("submission_id,course_code,course_title,semester")
-        .lt("semester", semester)
-        .order("semester")
-        .execute()
-        .data
-    )
-    ids = [row["submission_id"] for row in rows if row.get("submission_id")]
-    submissions = supabase.table("submissions").select("id,target_department,raw_course_content").in_("id", ids).execute().data if ids else []
-    departments = {row["id"]: row.get("target_department") for row in submissions}
-    raw_codes = {row["id"]: _course_code(row.get("raw_course_content") or "") for row in submissions}
-    titles = []
-    for row in rows:
-        if departments.get(row.get("submission_id")) != sub.get("target_department"):
-            continue
-        title = str(row.get("course_title") or "").strip()
-        code = str(row.get("course_code") or raw_codes.get(row.get("submission_id")) or "").strip()
-        label = f"{code} - {title}" if code else title
-        if title and label not in titles:
-            titles.append(label)
-    return titles
-
-
-def _normalized(text: str) -> str:
-    return re.sub(r"[^a-z0-9]+", " ", text.lower()).strip()
-
-
-def _singularized(text: str) -> str:
-    return " ".join(word[:-1] if len(word) > 3 and word.endswith("s") else word for word in _normalized(text).split())
-
-
-def _core_key(text: str) -> str:
-    skip = {"a", "an", "and", "for", "in", "its", "of", "the", "to", "with"}
-    return " ".join(word for word in _singularized(text).split() if word not in skip)
-
-
-def _prior_keys(course: str) -> list[str]:
-    match = re.match(r"\s*([A-Z]{2}\d{2}[A-Z0-9]+)\s*[-:]\s*(.+)", course)
-    code = match.group(1).lower() if match else ""
-    title = match.group(2) if match else course
-    return [key for key in (code, _normalized(title), _singularized(title), _core_key(title)) if key]
-
-
-def _prior_matches(text: str, prior_courses: list[str]) -> str:
-    normalized = _normalized(text)
-    singularized = _singularized(text)
-    core = _core_key(text)
-    matches = [course for course in prior_courses if any(key in normalized or key in singularized or key in core for key in _prior_keys(course))]
-    return ", ".join(matches)
-
-
-def _submitted_desirable(raw_content: str, prior_courses: list[str]) -> str | None:
-    match = DESIRABLE_LINE.search(raw_content or "")
-    if not match:
-        return None
-    value = _text(match.group(1))
-    if not value:
-        return ""
-    return _prior_matches(value, prior_courses) or None
-
-
-def _desirable(value, prior_courses: list[str], raw_content: str = "") -> str:
-    if not prior_courses:
-        return ""
-    submitted = _submitted_desirable(raw_content, prior_courses)
-    if submitted is not None:
-        return submitted
-    return _prior_matches(_text(value), prior_courses)
-
-
-def _courses_text(courses: list[str]) -> str:
-    return "\n".join(f"- {course}" for course in courses) if courses else "None"
-
-
-def build_refined_payload(sub: dict, out: dict, prior_courses: list[str] | None = None) -> dict:
-    out = out or {}
-    prior_courses = prior_courses or []
-    det = compute_hours(sub["credit_category"])
-    total_unit_hours = det["lecture_hours"] * 14
-    raw_content = sub.get("raw_course_content") or ""
-    text_book_source = _raw_book_section(raw_content, "text") or sub["text_books"]
-    reference_book_source = _raw_book_section(raw_content, "reference") or sub.get("reference_books")
-    units = _assign_hours(_fit_four_units(_units(out.get("units")), sub.get("raw_course_content") or ""), total_unit_hours)
-
-    objectives = _lines(out.get("objectives"))[:4]
-    course_outcomes = _lines(out.get("course_outcomes"))[:4] or objectives
-
-    return {
-        "submission_id": sub["id"],
-        "semester": int(sub["semester"]),
-        "course_code": _course_code(raw_content),
-        "course_title": _text(out.get("course_title"), sub["course_title"]),
-        "program": compute_program(sub["target_department"]),
-        "course_type": compute_course_type(sub["credit_category"]),
-        **det,
-        "prelude": _text(out.get("prelude"), f"This course covers {sub['course_title'].strip()}."),
-        "objectives": objectives,
-        "course_outcomes": course_outcomes,
-        "units": units,
-        "lab_experiments": _lines(out.get("lab_experiments"))[:10] if det["practical_hours"] else [],
-        "tools_languages": _text(out.get("tools_languages"), sub.get("preferred_tools")),
-        "desirable_knowledge": _desirable(out.get("desirable_knowledge"), prior_courses, raw_content),
-        "text_books": _books(text_book_source),
-        "reference_books": _books(reference_book_source),
-        "status": "refined",
-    }
-
-
-def refine(submission_id: int):
-    sub = first_row(supabase.table("submissions").select("*").eq("id", submission_id))
-    if not sub:
-        raise LookupError("Submission not found")
-    det = compute_hours(sub["credit_category"])
-    ctype = compute_course_type(sub["credit_category"])
-    total_unit_hours = det["lecture_hours"] * 14
-    prior_courses = _prior_course_titles(sub)
-
-    prompt = f"""Return JSON matching this schema. Include every key:
-{SCHEMA}
-
-{EXAMPLES}
-
-Now refine the real submission below.
-
-Course Title: {sub["course_title"]}
-Offering Department: {sub["offering_department"]}
-Target Department: {sub["target_department"]}
-Semester: {sub["semester"]}
-Credit Category: {sub["credit_category"]}
-Course Type: {ctype}
-Weekly Hours: L {det["lecture_hours"]}, T {det["tutorial_hours"]}, P {det["practical_hours"]}, S {det["self_study"]}, C {det["credits"]}
-Total Unit Hours: {total_unit_hours}
-Raw Course Content:
-{sub["raw_course_content"]}
-
-Previously Completed Courses:
-{_courses_text(prior_courses)}
-
-Text Books:
-{sub["text_books"]}
-
-Reference Books:
-{sub.get("reference_books") or "-"}
-
-Preferred Tools / Languages:
-{sub.get("preferred_tools") or "-"}"""
-
-    out = llm(SYS, prompt)
-    merged = build_refined_payload(sub, out, prior_courses)
-
-    existing = supabase.table("refined_submissions").select("id").eq("submission_id", submission_id).execute().data
-    if existing:
-        supabase.table("refined_submissions").update(merged).eq("submission_id", submission_id).execute()
-    else:
-        supabase.table("refined_submissions").insert(merged).execute()
-
-    supabase.table("submissions").update({"status": "refined"}).eq("id", submission_id).execute()
-
-    return merged

backend/app/services/schema.py

@@ -1,28 +0,0 @@
-from postgrest.exceptions import APIError
-
-from app.supabase import supabase
-
-REQUIRED_TABLES = (
-    "submissions",
-    "refined_submissions",
-    "curriculum_versions",
-    "finalized_submissions",
-    "agent_document_drafts",
-    "agent_drafts",
-    "course_revision_history",
-    "chat_sessions",
-    "chat_messages",
-    "chat_attachments",
-)
-
-
-def schema_status() -> dict:
-    missing = []
-    for table in REQUIRED_TABLES:
-        try:
-            supabase.table(table).select("id").limit(1).execute()
-        except APIError as exc:
-            if "schema cache" not in str(exc):
-                raise
-            missing.append(table)
-    return {"ok": not missing, "missing_tables": missing, "required_tables": list(REQUIRED_TABLES)}

backend/app/supabase.py

@@ -5,17 +5,12 @@ import httpx
 
 load_dotenv("../.env")
 
-url = environ["SUPABASE_URL"].strip()
-key = environ["SUPABASE_KEY"].strip()
-supabase = create_client(
+url=environ["SUPABASE_URL"]
+key=environ["SUPABASE_KEY"]
+supabase=create_client(
     supabase_url=url,
     supabase_key=key,
     options=ClientOptions(
         httpx_client=httpx.Client(http2=False),
     ),
-)
-
-
-def first_row(query) -> dict | None:
-    rows = query.limit(1).execute().data
-    return rows[0] if rows else None
+)

backend/app/templates/jinja_1_to_8.html

@@ -1,240 +0,0 @@
-{% macro semester_name(value) -%}
-  {{ {"1": "I", "2": "II", "3": "III", "4": "IV", "7": "VII", "8": "VIII"}.get(value|string, value) }}
-{%- endmacro %}
-
-{% macro course_row(course, number) -%}
-  <tr>
-    <td class="center">{{ number }}</td>
-    <td>{{ course.course_code | course_code_for_year(course.semester, curriculum_year) }}</td>
-    <td>{{ course.course_title }}</td>
-    <td class="center">{{ course.lecture_hours }}</td>
-    <td class="center">{{ course.tutorial_hours }}</td>
-    <td class="center">{{ course.practical_hours }}</td>
-    <td class="center">{{ course.self_study }}</td>
-    <td class="center">{{ course.credits }}</td>
-    <td>{{ course.tools_languages }}</td>
-    <td>{{ course.course_type }}</td>
-  </tr>
-{%- endmacro %}
-
-{% macro final_year_row(course, number) -%}
-  <tr>
-    <td class="center">{{ number }}</td>
-    <td>{{ course.course_code | course_code_for_year(course.semester, curriculum_year) }}</td>
-    <td>{{ course.course_title }}</td>
-    <td class="center">{{ course.lecture_hours }}</td>
-    <td class="center">{{ course.tutorial_hours }}</td>
-    <td class="center">{{ course.practical_hours }}</td>
-    <td class="center">{{ course.self_study }}</td>
-    <td class="center">{{ course.credits }}</td>
-    <td class="center">{{ course.course_type }}</td>
-  </tr>
-{%- endmacro %}
-
-{% macro total_cell(total, credit_total) -%}
-  {% if total != credit_total %}{{ credit_total }}/{{ total }}{% else %}{{ total }}{% endif %}
-{%- endmacro %}
-
-{% macro regular_table(summary_semester, show_total) -%}
-  {% set totals = namespace(count=0, lecture=0, lecture_credit=0, tutorial=0, practical=0, self_study=0, credits=0) %}
-  {% for summary_course in course_list %}
-    {% if summary_course.semester|string == summary_semester|string %}
-      {% set credit_value = summary_course.credits|int %}
-      {% set totals.count = totals.count + 1 %}
-      {% set totals.lecture = totals.lecture + summary_course.lecture_hours|int %}
-      {% set totals.tutorial = totals.tutorial + summary_course.tutorial_hours|int %}
-      {% set totals.practical = totals.practical + summary_course.practical_hours|int %}
-      {% set totals.self_study = totals.self_study + summary_course.self_study|int %}
-      {% set totals.credits = totals.credits + credit_value %}
-      {% if credit_value > 0 %}
-        {% set totals.lecture_credit = totals.lecture_credit + summary_course.lecture_hours|int %}
-      {% endif %}
-    {% endif %}
-  {% endfor %}
-
-  {% if totals.count %}
-    <h2 class="semester-title">{{ semester_name(summary_semester) }} SEMESTER {{ batch_label(summary_semester, curriculum_year) }}</h2>
-    <table class="meta summary-table">
-      <colgroup>
-        <col class="summary-number" />
-        <col class="summary-code" />
-        <col class="summary-title-column" />
-        <col class="summary-hour" />
-        <col class="summary-hour" />
-        <col class="summary-hour" />
-        <col class="summary-hour" />
-        <col class="summary-credit" />
-        <col class="summary-tools" />
-        <col class="summary-type" />
-      </colgroup>
-      <tbody>
-        <tr>
-          <th rowspan="2" class="center">Sl. No.</th>
-          <th rowspan="2">Course Code</th>
-          <th rowspan="2">Course Title</th>
-          <th colspan="4" class="center">Hours per week</th>
-          <th class="center nowrap">Credits</th>
-          <th rowspan="2">AI Tools / Tools /<br /> Languages</th>
-          <th rowspan="2">Course Type</th>
-        </tr>
-        <tr>
-          <th class="center">L</th>
-          <th class="center">T</th>
-          <th class="center">P</th>
-          <th class="center">S</th>
-          <th class="center">C</th>
-        </tr>
-
-        {% set row = namespace(number=1) %}
-        {% for summary_course in course_list %}
-          {% if summary_course.semester|string == summary_semester|string %}
-            {{ course_row(summary_course, row.number) }}
-            {% set row.number = row.number + 1 %}
-          {% endif %}
-        {% endfor %}
-
-        {% if show_total %}
-          <tr>
-            <th colspan="3" class="center">Total</th>
-            <td class="center">{{ total_cell(totals.lecture, totals.lecture_credit) }}</td>
-            <td class="center">{{ totals.tutorial }}</td>
-            <td class="center">{{ totals.practical }}</td>
-            <td class="center">{{ totals.self_study }}</td>
-            <td class="center">{{ totals.credits }}</td>
-            <td></td>
-            <td></td>
-          </tr>
-        {% endif %}
-      </tbody>
-    </table>
-  {% endif %}
-{%- endmacro %}
-
-{% set requested_semester = semester|string if semester is defined and semester else "" %}
-{% if summary_range | default("") != "final" %}
-  {% set early = namespace(count=0) %}
-  {% for summary_course in course_list %}
-    {% if summary_course.semester|string in ["1", "2"] and (not requested_semester or requested_semester == summary_course.semester|string) %}
-      {% set early.count = early.count + 1 %}
-    {% endif %}
-  {% endfor %}
-
-  {% if early.count %}
-    <article class="summary-page">
-      <header class="letterhead">
-        <img class="seal" src="{{ asset_root | default('') }}images/image2.png" alt="PES University logo" />
-        <img class="wordmark" src="{{ asset_root | default('') }}images/image1.png" alt="PES University" />
-      </header>
-      {% for summary_semester in [1, 2] %}
-        {% if not requested_semester or requested_semester == summary_semester|string %}
-          {{ regular_table(summary_semester, false) }}
-        {% endif %}
-      {% endfor %}
-    </article>
-  {% endif %}
-
-  {% for summary_semester in [3, 4] %}
-    {% if not requested_semester or requested_semester == summary_semester|string %}
-      {% set current = namespace(count=0) %}
-      {% for summary_course in course_list %}
-        {% if summary_course.semester|string == summary_semester|string %}
-          {% set current.count = current.count + 1 %}
-        {% endif %}
-      {% endfor %}
-
-      {% if current.count %}
-        <article class="summary-page">
-          <header class="letterhead">
-            <img class="seal" src="{{ asset_root | default('') }}images/image2.png" alt="PES University logo" />
-            <img class="wordmark" src="{{ asset_root | default('') }}images/image1.png" alt="PES University" />
-          </header>
-          {{ regular_table(summary_semester, true) }}
-        </article>
-      {% endif %}
-    {% endif %}
-  {% endfor %}
-{% endif %}
-
-{% if summary_range | default("") != "early" and (not requested_semester or requested_semester in ["7", "8"]) %}
-  {% set final = namespace(count=0) %}
-  {% for summary_course in course_list %}
-    {% if summary_course.semester|string in ["7", "8"] and (not requested_semester or requested_semester == summary_course.semester|string) %}
-      {% set final.count = final.count + 1 %}
-    {% endif %}
-  {% endfor %}
-
-  {% if final.count %}
-    <article class="summary-page final-year-summary">
-      <header class="letterhead">
-        <img class="seal" src="{{ asset_root | default('') }}images/image2.png" alt="PES University logo" />
-        <img class="wordmark" src="{{ asset_root | default('') }}images/image1.png" alt="PES University" />
-      </header>
-
-      {% for summary_semester in [7, 8] %}
-        {% if not requested_semester or requested_semester == summary_semester|string %}
-          {% set totals = namespace(count=0, lecture=0, tutorial=0, practical=0, self_study=0, credits=0) %}
-          {% for summary_course in course_list %}
-            {% if summary_course.semester|string == summary_semester|string %}
-              {% set totals.count = totals.count + 1 %}
-              {% set totals.lecture = totals.lecture + summary_course.lecture_hours|int %}
-              {% set totals.tutorial = totals.tutorial + summary_course.tutorial_hours|int %}
-              {% set totals.practical = totals.practical + summary_course.practical_hours|int %}
-              {% set totals.self_study = totals.self_study + summary_course.self_study|int %}
-              {% set totals.credits = totals.credits + summary_course.credits|int %}
-            {% endif %}
-          {% endfor %}
-
-          {% if totals.count %}
-            <h2 class="semester-title">{{ semester_name(summary_semester) }} SEMESTER {{ batch_label(summary_semester, curriculum_year) }}</h2>
-            <table class="meta summary-table final-year-table">
-              <colgroup>
-                <col class="final-number" />
-                <col class="final-code" />
-                <col class="final-title" />
-                <col class="final-hour" />
-                <col class="final-hour" />
-                <col class="final-hour" />
-                <col class="final-hour" />
-                <col class="final-credit" />
-                <col class="final-type" />
-              </colgroup>
-              <tbody>
-                <tr>
-                  <th rowspan="2" class="center">Sl. No.</th>
-                  <th rowspan="2">Course Code</th>
-                  <th rowspan="2">Course Title</th>
-                  <th colspan="4" class="center">Hours/week</th>
-                  <th class="center nowrap">Credits</th>
-                  <th rowspan="2" class="center">Course Type</th>
-                </tr>
-                <tr>
-                  <th class="center">L</th>
-                  <th class="center">T</th>
-                  <th class="center">P</th>
-                  <th class="center">S</th>
-                  <th class="center">C</th>
-                </tr>
-                {% set row = namespace(number=1) %}
-                {% for summary_course in course_list %}
-                  {% if summary_course.semester|string == summary_semester|string %}
-                    {{ final_year_row(summary_course, row.number) }}
-                    {% set row.number = row.number + 1 %}
-                  {% endif %}
-                {% endfor %}
-                <tr>
-                  <th colspan="3" class="center">Total</th>
-                  <td class="center">{{ totals.lecture }}</td>
-                  <td class="center">{{ totals.tutorial }}</td>
-                  <td class="center">{{ totals.practical }}</td>
-                  <td class="center">{{ totals.self_study }}</td>
-                  <td class="center">{{ totals.credits }}</td>
-                  <td></td>
-                </tr>
-              </tbody>
-            </table>
-          {% endif %}
-        {% endif %}
-      {% endfor %}
-    </article>
-  {% endif %}
-{% endif %}

backend/app/templates/jinja_sample.html

@@ -1,427 +1,1478 @@
-<!doctype html>
-<html lang="en">
+<html>
   <head>
-    <meta charset="UTF-8" />
-    <style>
-      @page {
-        size: A4;
-        margin: 14mm 12mm 18mm;
-
-        @bottom-left {
-          content: "P.E.S. University";
-          color: #fff;
-          font: 700 10pt Arial, sans-serif;
-          padding: 4pt 0 4pt 12mm;
-        }
-
-        @bottom-center {
-          content: "Curriculum :- {{ curriculum_year }}";
-          color: #fff;
-          font: 700 10pt Arial, sans-serif;
-          padding: 4pt 0;
-        }
-
-        @bottom-right {
-          content: counter(page) " | Page";
-          color: #fff;
-          font: 700 10pt Arial, sans-serif;
-          padding: 4pt 12mm 4pt 0;
-          text-align: right;
-        }
+    <meta content="text/html; charset=UTF-8" http-equiv="content-type" />
+    <style type="text/css">
+      .lst-kix_list_2-6 > li:before {
+        content: "\002022   ";
       }
-
-      * {
-        box-sizing: border-box;
+      .lst-kix_list_2-7 > li:before {
+        content: "\002022   ";
       }
-
-      body {
+      ol.lst-kix_list_1-0 {
+        list-style-type: none;
+      }
+      .lst-kix_list_2-4 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_2-5 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_2-8 > li:before {
+        content: "\002022   ";
+      }
+      ul.lst-kix_list_2-8 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_1-3 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-2 {
+        list-style-type: none;
+      }
+      .lst-kix_list_1-0 > li:before {
+        content: "" counter(lst-ctn-kix_list_1-0, decimal) ". ";
+      }
+      ul.lst-kix_list_1-4 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-3 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_1-1 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-0 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_1-2 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-1 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_1-7 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-6 {
+        list-style-type: none;
+      }
+      .lst-kix_list_1-1 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_1-2 > li:before {
+        content: "\002022   ";
+      }
+      ul.lst-kix_list_1-8 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-7 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_1-5 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-4 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_1-6 {
+        list-style-type: none;
+      }
+      ul.lst-kix_list_2-5 {
+        list-style-type: none;
+      }
+      .lst-kix_list_1-3 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_1-4 > li:before {
+        content: "\002022   ";
+      }
+      ol.lst-kix_list_1-0.start {
+        counter-reset: lst-ctn-kix_list_1-0 0;
+      }
+      .lst-kix_list_1-0 > li {
+        counter-increment: lst-ctn-kix_list_1-0;
+      }
+      li.li-bullet-1:before {
+        margin-left: -36.1pt;
+        white-space: nowrap;
+        display: inline-block;
+        min-width: 36.1pt;
+      }
+      .lst-kix_list_1-7 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_1-5 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_1-6 > li:before {
+        content: "\002022   ";
+      }
+      li.li-bullet-0:before {
+        margin-left: -18pt;
+        white-space: nowrap;
+        display: inline-block;
+        min-width: 18pt;
+      }
+      .lst-kix_list_2-0 > li:before {
+        content: "\0025cf   ";
+      }
+      .lst-kix_list_2-1 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_1-8 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_2-2 > li:before {
+        content: "\002022   ";
+      }
+      .lst-kix_list_2-3 > li:before {
+        content: "\002022   ";
+      }
+      ol {
         margin: 0;
-        color: #000;
-        font-family: Calibri, Arial, sans-serif;
-        font-size: 10pt;
-        line-height: 1.2;
+        padding: 0;
       }
-
-      .course + .course,
-      .summary-page + .summary-page,
-      .summary-page + .course {
-        break-before: page;
-        page-break-before: always;
+      table td,
+      table th {
+        padding: 0;
       }
-
-      .letterhead {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        gap: 12pt;
-        margin-bottom: 10pt;
+      .c11 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 71pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
       }
-
-      .seal {
-        width: 41px;
-        height: auto;
+      .c74 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 48.9pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
       }
-
-      .wordmark {
-        width: 265px;
-        height: auto;
+      .c19 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 42.5pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
       }
-
-      table {
-        width: 100%;
-        border-collapse: collapse;
-        table-layout: fixed;
+      .c60 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 441.2pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
       }
-
-      .meta {
-        margin-bottom: -1pt;
+      .c72 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 42.1pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
       }
-
-      th,
-      td {
-        border: 1pt solid #000;
-        padding: 4pt 5pt;
+      .c102 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
         vertical-align: top;
-        overflow-wrap: anywhere;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 35.5pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
       }
-
-      th {
+      .c24 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        background-color: #000000;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 49.6pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
+      }
+      .c32 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 441.2pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c61 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 0pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 0pt;
+        width: 30.4pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
+      }
+      .c44 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 441.2pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c15 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 48.9pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c14 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 49.6pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c49 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 0pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 0pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 17.3pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c80 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 48.9pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c63 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 76pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
+      }
+      .c43 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 42.5pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c46 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 42.5pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c34 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 35.5pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c52 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 42.1pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c18 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 0pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 0pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 0pt;
+        width: 17.3pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c30 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 71pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c29 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 0pt;
+        border-right-width: 0pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 0pt;
+        width: 30.4pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c31 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 76pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c37 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 0pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 0pt;
+        width: 17.3pt;
+        border-top-color: #d9d9d9;
+        border-bottom-style: solid;
+      }
+      .c5 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 76pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c64 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 218.6pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c10 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 49.6pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c59 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 42.1pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c99 {
+        border-right-style: solid;
+        border-bottom-color: #d9d9d9;
+        border-top-width: 0pt;
+        border-right-width: 0pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 30.4pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c23 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 71pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c22 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 35.5pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c20 {
+        border-right-style: solid;
+        border-bottom-color: #000000;
+        border-top-width: 1pt;
+        border-right-width: 1pt;
+        border-left-color: #000000;
+        vertical-align: top;
+        border-right-color: #000000;
+        border-left-width: 1pt;
+        border-top-style: solid;
+        border-left-style: solid;
+        border-bottom-width: 1pt;
+        width: 151.5pt;
+        border-top-color: #000000;
+        border-bottom-style: solid;
+      }
+      .c16 {
+        color: #000000;
         font-weight: 700;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 12pt;
+        font-family: "Calibri";
+        font-style: normal;
+      }
+      .c40 {
+        margin-left: 4.8pt;
+        padding-top: 5.3pt;
+        text-indent: -0.2pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
         text-align: left;
+        margin-right: 32.5pt;
       }
-
-      .center {
-        text-align: center;
+      .c1 {
+        color: #000000;
+        font-weight: 400;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 10pt;
+        font-family: "Calibri";
+        font-style: normal;
       }
-
-      .label {
-        width: 18%;
+      .c67 {
+        color: #000000;
+        font-weight: 700;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 10pt;
+        font-family: "Arial";
+        font-style: normal;
       }
-
-      .hour {
-        width: 7%;
+      .c62 {
+        margin-left: 40.2pt;
+        padding-top: 0.5pt;
+        padding-left: 0pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-align: left;
+        margin-right: 19pt;
       }
-
-      p {
-        margin: 0 0 5pt;
+      .c86 {
+        color: #000000;
+        font-weight: 400;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 10pt;
+        font-family: "Verdana";
+        font-style: normal;
       }
-
-      p:last-child {
-        margin-bottom: 0;
+      .c51 {
+        margin-left: 4.3pt;
+        padding-top: 0.4pt;
+        text-indent: -0.2pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-align: justify;
+        margin-right: 4.7pt;
       }
-
-      ul,
-      ol {
-        margin: 0;
-        padding-left: 16pt;
+      .c76 {
+        margin-left: 4.3pt;
+        padding-top: 0.5pt;
+        text-indent: -0.2pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-align: justify;
+        margin-right: 4.5pt;
       }
-
-      li {
-        margin-bottom: 3pt;
+      .c48 {
+        color: #000000;
+        font-weight: 400;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 7pt;
+        font-family: "Times New Roman";
+        font-style: normal;
       }
-
-      li:last-child {
-        margin-bottom: 0;
+      .c25 {
+        margin-left: 4.3pt;
+        padding-top: 0.6pt;
+        text-indent: -0.2pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-align: justify;
+        margin-right: 4.9pt;
       }
-
-      .unit-title,
-      .hours {
+      .c101 {
+        color: #ffffff;
         font-weight: 700;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 10pt;
+        font-family: "Arial";
+        font-style: normal;
       }
-
-      .unit {
-        margin-bottom: 8pt;
+      .c2 {
+        color: #000000;
+        font-weight: 400;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 12pt;
+        font-family: "Times New Roman";
+        font-style: normal;
       }
-
-      .unit:last-child {
-        margin-bottom: 0;
+      .c3 {
+        color: #000000;
+        font-weight: 700;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 10pt;
+        font-family: "Calibri";
+        font-style: normal;
       }
-
-      .hours {
-        text-align: right;
+      .c96 {
+        margin-left: 4.3pt;
+        padding-top: 0.6pt;
+        text-indent: -0.2pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-align: justify;
+        margin-right: 5.2pt;
       }
-
-      .resource-link {
-        color: inherit;
-        text-decoration: underline;
+      .c9 {
+        color: #000000;
+        font-weight: 400;
+        text-decoration: none;
+        vertical-align: baseline;
+        font-size: 9pt;
+        font-family: "Times New Roman";
+        font-style: normal;
       }
-
-      .semester-title {
-        margin: 0 0 8pt;
+      .c12 {
+        margin-left: 22.2pt;
+        padding-top: 0.5pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        padding-left: 18.1pt;
+        text-align: left;
+      }
+      .c47 {
+        margin-left: 10.3pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
         text-align: center;
-        font-size: 11pt;
-        font-weight: 700;
+        margin-right: 11.1pt;
       }
-
-      .summary-table {
-        margin-bottom: 8pt;
+      .c17 {
+        margin-left: 40.2pt;
+        padding-top: 0.5pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        padding-left: 0pt;
+        text-align: left;
       }
-
-      .specialization-table p {
-        margin: 0 0 2pt;
+      .c35 {
+        margin-left: 22.2pt;
+        padding-top: 5.2pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        padding-left: 18.1pt;
+        text-align: left;
       }
-
-      .summary-table th,
-      .summary-table td {
-        padding: 3pt 4pt;
-        font-size: 9pt;
+      .c28 {
+        margin-left: 40.2pt;
+        padding-top: 5.2pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        padding-left: 0pt;
+        text-align: left;
       }
-
-      .summary-table th {
-        font-size: 8.5pt;
+      .c97 {
+        margin-left: 22.2pt;
+        padding-top: 0.6pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        padding-left: 18.1pt;
+        text-align: left;
       }
-
-      .summary-number {
-        width: 6%;
+      .c13 {
+        margin-left: 4.3pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-indent: -0.2pt;
+        text-align: left;
       }
-
-      .summary-code {
-        width: 16%;
+      .c91 {
+        margin-left: 40.2pt;
+        padding-top: 0.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        padding-left: 0pt;
+        text-align: left;
       }
-
-      .summary-title-column {
-        width: 18%;
+      .c65 {
+        margin-left: 4.8pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1.0291666666666666;
+        text-indent: -0.2pt;
+        text-align: left;
       }
-
-      .summary-hour {
-        width: 5.5%;
+      .c90 {
+        margin-left: 16pt;
+        padding-top: 1.1pt;
+        padding-bottom: 0pt;
+        line-height: 0.6958333333333333;
+        text-align: left;
+        margin-right: -2.2pt;
       }
-
-      .summary-credit {
-        width: 8%;
+      .c57 {
+        margin-left: 0.6pt;
+        padding-top: 1.1pt;
+        padding-bottom: 0pt;
+        line-height: 0.7000000000000001;
+        text-align: left;
+        margin-right: -2.9pt;
       }
-
-      .summary-tools {
-        width: 18%;
+      .c36 {
+        margin-left: 4.2pt;
+        padding-top: 0.1pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
       }
-
-      .summary-type {
-        width: 12%;
+      .c92 {
+        margin-left: 4.8pt;
+        padding-top: 5.2pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
       }
-
-      .nowrap {
-        white-space: nowrap;
+      .c69 {
+        margin-left: 19.5pt;
+        padding-top: 11.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
       }
-
-      .summary-table td:nth-child(8),
-      .summary-table th:nth-child(8) {
+      .c83 {
+        margin-left: 399.5pt;
+        padding-top: 0.1pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: justify;
+      }
+      .c45 {
+        margin-left: 398.5pt;
+        padding-top: 0.1pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: justify;
+      }
+      .c55 {
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
         text-align: center;
+        margin-right: 0.6pt;
       }
-
-      .summary-table td:nth-child(n + 4):nth-child(-n + 8),
-      .summary-table th:nth-child(n + 4):nth-child(-n + 8) {
-        padding-left: 2pt;
-        padding-right: 2pt;
-        white-space: nowrap;
+      .c103 {
+        margin-left: 4.2pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
       }
-
-      .summary-table td:nth-child(2),
-      .summary-table th:nth-child(2) {
-        white-space: nowrap;
+      .c21 {
+        margin-left: 4.2pt;
+        padding-top: 0.5pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: justify;
       }
-
-      .final-number {
-        width: 7%;
+      .c6 {
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: center;
+        margin-right: 0.3pt;
       }
-
-      .final-code {
-        width: 16%;
+      .c33 {
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: center;
+        margin-right: 0.4pt;
       }
-
-      .final-title {
-        width: 23%;
+      .c4 {
+        padding-top: 0pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+        height: 11pt;
       }
-
-      .final-hour {
-        width: 6%;
+      .c77 {
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: center;
+        margin-right: 0.7pt;
       }
-
-      .final-credit {
-        width: 8%;
+      .c7 {
+        margin-left: 398.5pt;
+        padding-top: 0pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: justify;
       }
-
-      .final-type {
-        width: 22%;
+      .c27 {
+        padding-top: 0pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: right;
+        margin-right: 3.4pt;
       }
-
-      .empty {
-        margin-top: 18pt;
+      .c89 {
+        margin-left: 398.5pt;
+        padding-top: 0pt;
+        padding-bottom: 0pt;
+        line-height: 1.0125;
+        text-align: justify;
+      }
+      .c75 {
+        margin-left: 4.8pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c0 {
+        margin-left: 4.5pt;
+        padding-top: 0.6pt;
+        padding-bottom: 0pt;
+        line-height: 1.0374999999999999;
+        text-align: left;
+      }
+      .c95 {
+        margin-left: 4.3pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c39 {
+        margin-left: 4.5pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c87 {
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
         text-align: center;
+        margin-right: 0.2pt;
+      }
+      .c88 {
+        margin-left: 4.2pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: justify;
+      }
+      .c93 {
+        margin-left: 48.5pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c81 {
+        margin-left: 10.1pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c53 {
+        margin-left: 18.9pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c58 {
+        margin-left: 11.3pt;
+        padding-top: 5.3pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c8 {
+        padding-top: 0pt;
+        padding-bottom: 0pt;
+        line-height: 1.15;
+        text-align: left;
+        height: 11pt;
+      }
+      .c42 {
+        display: flex;
+        align-items: center;
+        justify-content: flex-start;
+        gap: 10px;
+        padding-top: 6pt;
+        padding-bottom: 0pt;
+        text-align: left;
+      }
+      .c82 {
+        padding-top: 12.9pt;
+        padding-bottom: 0pt;
+        line-height: 1;
+        text-align: left;
+      }
+      .c38 {
+        margin-left: 3.4pt;
+        border-spacing: 0;
+        border-collapse: collapse;
+        margin-right: auto;
+      }
+      .c79 {
+        color: #7e7e7e;
+        font-size: 12pt;
         font-weight: 700;
       }
-
-      .footer-bar {
-        position: fixed;
-        left: 0;
-        right: 0;
-        bottom: -14mm;
-        height: 9mm;
+      .c71 {
+        background-color: #ffffff;
+        max-width: 576pt;
+        margin: 0 auto;
+        padding: 75pt 24pt 14pt 24pt;
+      }
+      .c70 {
+        padding: 0;
+        margin: 0;
+      }
+      .c41 {
+        height: 81pt;
+      }
+      .c56 {
+        margin-right: 19.3pt;
+      }
+      .c50 {
+        height: 38pt;
+      }
+      .c68 {
+        height: 35.6pt;
+      }
+      .c94 {
+        height: 282.2pt;
+      }
+      .c98 {
+        height: 10.5pt;
+      }
+      .c78 {
+        height: 24.3pt;
+      }
+      .c85 {
+        height: 66.1pt;
+      }
+      .c66 {
+        margin-left: 0.1pt;
+      }
+      .c84 {
+        height: 24.2pt;
+      }
+      .c73 {
+        height: 50.2pt;
+      }
+      .c54 {
+        margin-right: 34.5pt;
+      }
+      .c26 {
+        margin-right: 3.8pt;
+      }
+      .c100 {
+        height: 62.5pt;
+      }
+      .title {
+        padding-top: 24pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 36pt;
+        padding-bottom: 6pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+      .subtitle {
+        padding-top: 18pt;
+        color: #666666;
+        font-size: 24pt;
+        padding-bottom: 4pt;
+        font-family: "Georgia";
+        line-height: 1;
+        page-break-after: avoid;
+        font-style: italic;
+        text-align: left;
+      }
+      li {
+        color: #000000;
+        font-size: 11pt;
+        font-family: "Calibri";
+      }
+      p {
+        margin: 0;
+        color: #000000;
+        font-size: 11pt;
+        font-family: "Calibri";
+      }
+      h1 {
+        padding-top: 24pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 24pt;
+        padding-bottom: 6pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+      h2 {
+        padding-top: 18pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 18pt;
+        padding-bottom: 4pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+      h3 {
+        padding-top: 14pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 14pt;
+        padding-bottom: 4pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+      h4 {
+        padding-top: 12pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 12pt;
+        padding-bottom: 2pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+      h5 {
+        padding-top: 11pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 11pt;
+        padding-bottom: 2pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+      h6 {
+        padding-top: 10pt;
+        color: #000000;
+        font-weight: 700;
+        font-size: 10pt;
+        padding-bottom: 2pt;
+        font-family: "Calibri";
+        line-height: 1;
+        page-break-after: avoid;
+        text-align: left;
+      }
+    </style>
+    <style>
+      .page-footer {
         background: #000;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 4pt 16pt;
+      }
+      .footer-text {
+        color: #fff;
+        font-weight: 700;
+        font-size: 10pt;
+        font-family: Arial, sans-serif;
+        white-space: nowrap;
+      }
+      .footer-page {
+        color: #fff;
+        font-weight: 700;
+        font-size: 12pt;
+        font-family: Calibri, sans-serif;
+        white-space: nowrap;
       }
     </style>
   </head>
-  <body>
-    <div class="footer-bar"></div>
-    {% set course_list = courses if courses is defined else [course] %}
-    {% if course_list %}
-      {% if show_summaries | default(false) %}
-        {% set summary_range = "early" %}
-        {% include "jinja_1_to_8.html" %}
-        {% include "jinja_sem_5_6.html" %}
-        {% set summary_range = "final" %}
-        {% include "jinja_1_to_8.html" %}
-      {% endif %}
-      {% for course in course_list %}
-        {% if not show_summaries | default(false) or course.render_detail | default(true) %}
-        <article class="course">
-          <header class="letterhead">
-            <img class="seal" src="{{ asset_root | default('') }}images/image2.png" alt="PES University logo" />
-            <img class="wordmark" src="{{ asset_root | default('') }}images/image1.png" alt="PES University" />
-          </header>
-
-          <table class="meta">
-            <colgroup>
-              <col class="label" />
-              <col />
-              <col class="label" />
-              <col class="hour" />
-              <col class="hour" />
-              <col class="hour" />
-              <col class="hour" />
-              <col class="hour" />
-            </colgroup>
-            <tbody>
-              <tr>
-                <th>Course Code</th>
-                <td>{{ course.course_code | course_code_for_year(course.semester, curriculum_year) }}</td>
-                <th>Course Title</th>
-                <td colspan="5">{{ course.course_title }}</td>
-              </tr>
-              <tr>
-                <th rowspan="2">Program</th>
-                <td rowspan="2">{{ course.program }}</td>
-                <th rowspan="2">Hours per week/ Credit Assigned</th>
-                <th class="center">L</th>
-                <th class="center">T</th>
-                <th class="center">P</th>
-                <th class="center">S</th>
-                <th class="center">C</th>
-              </tr>
-              <tr>
-                <td class="center">{{ course.lecture_hours }}</td>
-                <td class="center">{{ course.tutorial_hours }}</td>
-                <td class="center">{{ course.practical_hours }}</td>
-                <td class="center">{{ course.self_study }}</td>
-                <td class="center">{{ course.credits }}</td>
-              </tr>
-              <tr>
-                <th>Semester</th>
-                <td>{{ course.semester }}</td>
-                <th>Type of Course</th>
-                <td colspan="5">{{ course.course_type }}</td>
-              </tr>
-              <tr>
-                <th>AI Tools / Tools / Languages</th>
-                <td>{{ course.tools_languages }}</td>
-                <th>Desirable Knowledge</th>
-                <td colspan="5">{{ course.desirable_knowledge }}</td>
-              </tr>
-            </tbody>
-          </table>
-
-          <table>
-            <colgroup>
-              <col class="label" />
-              <col />
-            </colgroup>
-            <tbody>
-              <tr>
-                <th>Prelude</th>
-                <td>{{ course.prelude }}</td>
-              </tr>
-              <tr>
-                <th>Course Objectives:</th>
-                <td>
-                  <ul>
-                    {% for objective in course.objectives %}
-                      <li>{{ objective }}</li>
-                    {% endfor %}
-                  </ul>
-                </td>
-              </tr>
-              <tr>
-                <th>Course Contents</th>
-                <td>
-                  {% if course.units %}
-                    {% for unit in course.units %}
-                      <div class="unit">
-                        <p class="unit-title">{{ unit.title }}</p>
-                        <p>{{ unit.content }}</p>
-                        <p class="hours">{{ unit.hours }} Hours</p>
-                      </div>
-                    {% endfor %}
-                  {% else %}
-                    -
-                  {% endif %}
-                </td>
-              </tr>
-              {% if course.lab_experiments %}
-                <tr>
-                  <th>Laboratory</th>
-                  <td>
-                    <ol>
-                      {% for experiment in course.lab_experiments %}
-                        <li>{{ experiment }}</li>
-                      {% endfor %}
-                    </ol>
-                  </td>
-                </tr>
-              {% endif %}
-              <tr>
-                <th>Text Book(s):</th>
-                <td>
-                  {% if course.text_books %}
-                    <ol>
-                      {% for book in course.text_books %}
-                        <li>{{ book | linkify }}</li>
-                      {% endfor %}
-                    </ol>
-                  {% else %}
-                    -
-                  {% endif %}
-                </td>
-              </tr>
-              {% if course.reference_books %}
-                <tr>
-                  <th>Reference Book(s):</th>
-                  <td>
-                    <ol>
-                      {% for book in course.reference_books %}
-                        <li>{{ book | linkify }}</li>
-                      {% endfor %}
-                    </ol>
-                  </td>
-                </tr>
-              {% endif %}
-              {% if course.course_outcomes %}
-                <tr>
-                  <th>Course Outcome</th>
-                  <td>
-                    <ul>
-                      {% for outcome in course.course_outcomes %}
-                        <li>{{ outcome }}</li>
-                      {% endfor %}
-                    </ul>
-                  </td>
-                </tr>
-              {% endif %}
-            </tbody>
-          </table>
-        </article>
-        {% endif %}
-      {% endfor %}
-    {% else %}
-      <div class="empty">No refined courses found for Semester {{ semester }}.</div>
-    {% endif %}
+  <body class="c71 doc-content">
+    <div>
+      <p class="c42">
+        <span
+          style="
+            overflow: hidden;
+            display: inline-block;
+            margin: 0px 0px;
+            border: 0px solid #000000;
+            transform: rotate(0rad) translateZ(0px);
+            -webkit-transform: rotate(0rad) translateZ(0px);
+            width: 41.07px;
+            height: 49.96px;
+          "
+          ><img
+            alt
+            src="images/image2.png"
+            style="
+              width: 41.07px;
+              height: 49.96px;
+              margin-left: 0px;
+              margin-top: 0px;
+              transform: rotate(0rad) translateZ(0px);
+              -webkit-transform: rotate(0rad) translateZ(0px);
+            "
+            title /></span
+        ><span
+          style="
+            overflow: hidden;
+            display: inline-block;
+            margin: 0px 0px;
+            border: 0px solid #000000;
+            transform: rotate(0rad) translateZ(0px);
+            -webkit-transform: rotate(0rad) translateZ(0px);
+            width: 264.73px;
+            height: 19.87px;
+          "
+          ><img
+            alt
+            src="images/image1.png"
+            style="
+              width: 264.73px;
+              height: 19.87px;
+              margin-left: 0px;
+              margin-top: 0px;
+              transform: rotate(0rad) translateZ(0px);
+              -webkit-transform: rotate(0rad) translateZ(0px);
+            "
+            title
+        /></span>
+      </p>
+    </div>
+    <p class="c4"><span class="c2"></span></p>
+    <table class="c38">
+      <tr class="c78">
+        <td class="c18" colspan="1" rowspan="9">
+          <p class="c4"><span class="c9"></span></p>
+        </td>
+        <td class="c5" colspan="1" rowspan="1">
+          <p class="c58"><span class="c3">Course Code</span></p>
+        </td>
+        <td class="c20" colspan="1" rowspan="1">
+          <p class="c93"><span class="c3">{{ course.course_code }}</span></p>
+        </td>
+        <td class="c23" colspan="1" rowspan="1">
+          <p class="c81"><span class="c3">Course Title</span></p>
+        </td>
+        <td class="c64" colspan="5" rowspan="1">
+          <p class="c53">
+            <span class="c3">{{ course.course_title }}</span>
+          </p>
+        </td>
+        <td class="c29" colspan="1" rowspan="9">
+          <p class="c4"><span class="c9"></span></p>
+        </td>
+      </tr>
+      <tr class="c84">
+        <td class="c5" colspan="1" rowspan="2">
+          <p class="c69"><span class="c3">Program</span></p>
+        </td>
+        <td class="c20" colspan="1" rowspan="2">
+          <p class="c77"><span class="c1">{{ course.program }}</span></p>
+        </td>
+        <td class="c23" colspan="1" rowspan="2">
+          <p class="c47">
+            <span class="c3">Hours per week/ Credit Assigned</span>
+          </p>
+        </td>
+        <td class="c59" colspan="1" rowspan="1">
+          <p class="c55 c66"><span class="c3">L</span></p>
+        </td>
+        <td class="c15" colspan="1" rowspan="1">
+          <p class="c6"><span class="c3">T</span></p>
+        </td>
+        <td class="c14" colspan="1" rowspan="1">
+          <p class="c87 c66"><span class="c3">P</span></p>
+        </td>
+        <td class="c22" colspan="1" rowspan="1">
+          <p class="c6 c66"><span class="c3">S</span></p>
+        </td>
+        <td class="c43" colspan="1" rowspan="1">
+          <p class="c33"><span class="c3">C</span></p>
+        </td>
+      </tr>
+      <tr class="c68">
+        <td class="c59" colspan="1" rowspan="1">
+          <p class="c55"><span class="c3">{{ course.lecture_hours }}</span></p>
+        </td>
+        <td class="c15" colspan="1" rowspan="1">
+          <p class="c6 c66"><span class="c3">{{ course.tutorial_hours }}</span></p>
+        </td>
+        <td class="c14" colspan="1" rowspan="1">
+          <p class="c87"><span class="c3">{{ course.practical_hours }}</span></p>
+        </td>
+        <td class="c22" colspan="1" rowspan="1">
+          <p class="c6"><span class="c3">{{ course.self_study }}</span></p>
+        </td>
+        <td class="c43" colspan="1" rowspan="1">
+          <p class="c33"><span class="c3">{{ course.credits }}</span></p>
+        </td>
+      </tr>
+      <tr class="c50">
+        <td class="c5" colspan="1" rowspan="1">
+          <p class="c95"><span class="c3">Semester</span></p>
+        </td>
+        <td class="c20" colspan="1" rowspan="1">
+          <p class="c103"><span class="c1">{{ course.semester }}</span></p>
+        </td>
+        <td class="c23" colspan="1" rowspan="1">
+          <p class="c13 c54"><span class="c3">Type of Course</span></p>
+        </td>
+        <td class="c64" colspan="5" rowspan="1">
+          <p class="c39"><span class="c1">{{ course.course_type }}</span></p>
+        </td>
+      </tr>
+      <tr class="c73">
+        <td class="c5" colspan="1" rowspan="1">
+          <p class="c95"><span class="c3">AI Tools</span></p>
+          <p class="c0"><span class="c3">/Tools/Languag es</span></p>
+        </td>
+        <td class="c20" colspan="1" rowspan="1">
+          <p class="c13">
+            <span class="c1">{{ course.tools_languages }}</span>
+          </p>
+        </td>
+        <td class="c23" colspan="1" rowspan="1">
+          <p class="c13 c56"><span class="c3">Desirable Knowledge</span></p>
+        </td>
+        <td class="c64" colspan="5" rowspan="1">
+          <p class="c39"><span class="c1">{{ course.desirable_knowledge }}</span></p>
+        </td>
+      </tr>
+      <tr class="c85">
+        <td class="c5" colspan="1" rowspan="1">
+          <p class="c75"><span class="c3">Prelude</span></p>
+        </td>
+        <td class="c44" colspan="7" rowspan="1">
+          <p class="c13 c26">
+            <span class="c1">{{ course.prelude }}</span>
+          </p>
+        </td>
+      </tr>
+      <tr class="c41">
+        <td class="c5" colspan="1" rowspan="1">
+          <p class="c65"><span class="c3">Course Objectives:</span></p>
+        </td>
+        <td class="c44" colspan="7" rowspan="1">
+          <ul class="c70 lst-kix_list_2-0 start">
+            {% for obj in course.objectives %}
+            <li class="c28 li-bullet-0">
+              <span class="c1">{{ obj }}</span>
+            </li>
+            {% endfor %}
+          </ul>
+        </td>
+      </tr>
+      <tr class="c94">
+        <td class="c5" colspan="1" rowspan="1">
+          <p class="c40"><span class="c3">Course Contents</span></p>
+        </td>
+        <td class="c44" colspan="7" rowspan="1">
+          {% for unit in course.units %}
+          <p class="c88"><span class="c3">{{ unit.title }}</span></p>
+          <p class="c25">
+            <span class="c1">{{ unit.content }}</span>
+          </p>
+          <p class="c7"><span class="c3">{{ unit.hours }} Hours</span></p>
+          {% endfor %}
+        </td>
+      </tr>
+      <tr class="c100">
+        <td class="c31" colspan="1" rowspan="1">
+          <p class="c92"><span class="c3">Laboratory</span></p>
+        </td>
+        <td class="c32" colspan="7" rowspan="1">
+          <ol class="c70 lst-kix_list_1-0 start">
+            {% for exp in course.lab_experiments %}
+            <li class="c35 li-bullet-1">
+              <span class="c1">{{ exp }}</span>
+            </li>
+            {% endfor %}
+          </ol>
+        </td>
+      </tr>
+      <tr>
+        <td colspan="11" class="page-footer">
+          <span class="footer-text">P.E.S. University</span>
+          <span class="footer-text">Curriculum :- {{ curriculum_year }} <span class="footer-page">{{ page_number }} |</span></span>
+        </td>
+      </tr>
+    </table>
   </body>
 </html>
+

backend/app/templates/jinja_sem_5_6.html

@@ -1,238 +0,0 @@
-{% macro semester_name(value) -%}
-  {{ {"5": "V", "6": "VI"}.get(value|string, value) }}
-{%- endmacro %}
-
-{% macro course_row(course, number) -%}
-  {% set code = course.course_code|string|upper|replace(" ", "") %}
-  {% set title = course.course_title|string|lower %}
-  {% set is_placeholder = code.endswith("X") or title in ["elective i", "elective ii", "elective iii", "elective iv"] %}
-  {% set is_no_course = "no course offered" in title %}
-  {% set is_elective = ("AA" in code or "AB" in code or "BA" in code or "BB" in code) and not is_placeholder and not is_no_course %}
-  <tr>
-    <td class="center">{{ number }}</td>
-    <td>{{ course.course_code | course_code_for_year(course.semester, curriculum_year) }}</td>
-    <td>{{ course.course_title }}</td>
-    <td class="center">{% if is_no_course %}{% elif is_elective %}4{% else %}{{ course.lecture_hours }}{% endif %}</td>
-    <td class="center">{% if is_no_course %}{% elif is_elective %}0{% else %}{{ course.tutorial_hours }}{% endif %}</td>
-    <td class="center">{% if is_no_course %}{% elif is_elective %}0{% else %}{{ course.practical_hours }}{% endif %}</td>
-    <td class="center">{% if is_no_course %}{% elif is_elective %}4{% else %}{{ course.self_study }}{% endif %}</td>
-    <td class="center">{% if is_no_course %}{% elif is_elective %}4{% else %}{{ course.credits }}{% endif %}</td>
-    <td>{{ course.tools_languages }}</td>
-    <td>{% if is_no_course %}{% elif is_elective or is_placeholder %}Elective Course{% else %}{{ course.course_type }}{% endif %}</td>
-  </tr>
-{%- endmacro %}
-
-{% macro total_cell(total, credit_total) -%}
-  {% if total != credit_total %}{{ credit_total }}/{{ total }}{% else %}{{ total }}{% endif %}
-{%- endmacro %}
-
-{% macro specialization_codes(codes, summary_semester, curriculum_year) -%}
-  {% for code in codes %}
-    <p>{{ ("UE00CS" ~ code) | course_code_for_year(summary_semester, curriculum_year) }}</p>
-  {% endfor %}
-{%- endmacro %}
-
-{% set requested_semester = semester|string if semester is defined and semester else "" %}
-{% for summary_semester in [5, 6] %}
-  {% if not requested_semester or requested_semester == summary_semester|string %}
-    {% set totals = namespace(count=0, lecture=0, lecture_credit=0, tutorial=0, practical=0, self_study=0, credits=0) %}
-    {% for summary_course in course_list %}
-      {% set code = summary_course.course_code|string|upper|replace(" ", "") %}
-      {% set title = summary_course.course_title|string|lower %}
-      {% set course_type = summary_course.course_type|string|lower %}
-      {% set is_placeholder = code.endswith("X") or title in ["elective i", "elective ii", "elective iii", "elective iv"] %}
-      {% set has_elective_code = "AA" in code or "AB" in code or "BA" in code or "BB" in code %}
-      {% set is_actual_elective = has_elective_code and not is_placeholder %}
-      {% if summary_course.semester|string == summary_semester|string and not is_actual_elective %}
-        {% set credit_value = summary_course.credits|int %}
-        {% set totals.count = totals.count + 1 %}
-        {% set totals.lecture = totals.lecture + summary_course.lecture_hours|int %}
-        {% set totals.tutorial = totals.tutorial + summary_course.tutorial_hours|int %}
-        {% set totals.practical = totals.practical + summary_course.practical_hours|int %}
-        {% set totals.self_study = totals.self_study + summary_course.self_study|int %}
-        {% set totals.credits = totals.credits + credit_value %}
-        {% if credit_value > 0 %}
-          {% set totals.lecture_credit = totals.lecture_credit + summary_course.lecture_hours|int %}
-        {% endif %}
-      {% endif %}
-    {% endfor %}
-
-    {% set elective_a = namespace(count=0) %}
-    {% set elective_b = namespace(count=0) %}
-    {% for summary_course in course_list %}
-      {% set code = summary_course.course_code|string|upper|replace(" ", "") %}
-      {% set title = summary_course.course_title|string|lower %}
-      {% set course_type = summary_course.course_type|string|lower %}
-      {% set is_placeholder = code.endswith("X") or title in ["elective i", "elective ii", "elective iii", "elective iv"] %}
-      {% set is_elective = not is_placeholder %}
-      {% if summary_course.semester|string == summary_semester|string and is_elective %}
-        {% if summary_semester == 5 and "AA" in code %}
-          {% set elective_a.count = elective_a.count + 1 %}
-        {% elif summary_semester == 5 and "AB" in code %}
-          {% set elective_b.count = elective_b.count + 1 %}
-        {% elif summary_semester == 6 and "BA" in code %}
-          {% set elective_a.count = elective_a.count + 1 %}
-        {% elif summary_semester == 6 and "BB" in code %}
-          {% set elective_b.count = elective_b.count + 1 %}
-        {% endif %}
-      {% endif %}
-    {% endfor %}
-
-    {% if totals.count or elective_a.count or elective_b.count %}
-      <article class="summary-page">
-        <header class="letterhead">
-          <img class="seal" src="{{ asset_root | default('') }}images/image2.png" alt="PES University logo" />
-          <img class="wordmark" src="{{ asset_root | default('') }}images/image1.png" alt="PES University" />
-        </header>
-        <h2 class="semester-title">{{ semester_name(summary_semester) }} SEMESTER {{ batch_label(summary_semester, curriculum_year) }}</h2>
-
-        {% if totals.count %}
-          <table class="meta summary-table">
-            <colgroup>
-              <col class="summary-number" />
-              <col class="summary-code" />
-              <col class="summary-title-column" />
-              <col class="summary-hour" />
-              <col class="summary-hour" />
-              <col class="summary-hour" />
-              <col class="summary-hour" />
-              <col class="summary-credit" />
-              <col class="summary-tools" />
-              <col class="summary-type" />
-            </colgroup>
-            <tbody>
-              <tr>
-                <th rowspan="2" class="center">Sl. No.</th>
-                <th rowspan="2">Course Code</th>
-                <th rowspan="2">Course Title</th>
-                <th colspan="4" class="center">Hours per week</th>
-                <th class="center nowrap">Credits</th>
-                <th rowspan="2">AI Tools / Tools /<br /> Languages</th>
-                <th rowspan="2">Course Type</th>
-              </tr>
-              <tr>
-                <th class="center">L</th>
-                <th class="center">T</th>
-                <th class="center">P</th>
-                <th class="center">S</th>
-                <th class="center">C</th>
-              </tr>
-              {% set row = namespace(number=1) %}
-              {% for summary_course in course_list %}
-                {% set code = summary_course.course_code|string|upper|replace(" ", "") %}
-                {% set title = summary_course.course_title|string|lower %}
-                {% set course_type = summary_course.course_type|string|lower %}
-                {% set is_placeholder = code.endswith("X") or title in ["elective i", "elective ii", "elective iii", "elective iv"] %}
-                {% set has_elective_code = "AA" in code or "AB" in code or "BA" in code or "BB" in code %}
-                {% set is_actual_elective = has_elective_code and not is_placeholder %}
-                {% if summary_course.semester|string == summary_semester|string and not is_actual_elective %}
-                  {{ course_row(summary_course, row.number) }}
-                  {% set row.number = row.number + 1 %}
-                {% endif %}
-              {% endfor %}
-              <tr>
-                <th colspan="3" class="center">Total</th>
-                <td class="center">{{ total_cell(totals.lecture, totals.lecture_credit) }}</td>
-                <td class="center">{{ totals.tutorial }}</td>
-                <td class="center">{{ totals.practical }}</td>
-                <td class="center">{{ totals.self_study }}</td>
-                <td class="center">{{ totals.credits }}</td>
-                <td></td>
-                <td></td>
-              </tr>
-            </tbody>
-          </table>
-        {% endif %}
-
-        {% for group in ["a", "b"] %}
-            <table class="meta summary-table">
-              <colgroup>
-                <col class="summary-number" />
-                <col class="summary-code" />
-                <col class="summary-title-column" />
-                <col class="summary-hour" />
-                <col class="summary-hour" />
-                <col class="summary-hour" />
-                <col class="summary-hour" />
-                <col class="summary-credit" />
-                <col class="summary-tools" />
-                <col class="summary-type" />
-              </colgroup>
-              <tbody>
-                <tr>
-                  <th colspan="10" class="center">
-                    {% if summary_semester == 5 and group == "a" %}Elective-I{% endif %}
-                    {% if summary_semester == 5 and group == "b" %}Elective-II{% endif %}
-                    {% if summary_semester == 6 and group == "a" %}Elective-III{% endif %}
-                    {% if summary_semester == 6 and group == "b" %}Elective-IV{% endif %}
-                  </th>
-                </tr>
-                {% set start_number = totals.count + 1 if group == "a" else totals.count + elective_a.count + 1 %}
-                {% set row = namespace(number=start_number) %}
-                {% for summary_course in course_list %}
-                  {% set code = summary_course.course_code|string|upper|replace(" ", "") %}
-                  {% set title = summary_course.course_title|string|lower %}
-                  {% set course_type = summary_course.course_type|string|lower %}
-                  {% set is_placeholder = code.endswith("X") or title in ["elective i", "elective ii", "elective iii", "elective iv"] %}
-                  {% set is_elective = not is_placeholder %}
-                  {% set is_group_a = (summary_semester == 5 and "AA" in code) or (summary_semester == 6 and "BA" in code) %}
-                  {% set is_group_b = (summary_semester == 5 and "AB" in code) or (summary_semester == 6 and "BB" in code) %}
-                  {% if summary_course.semester|string == summary_semester|string and is_elective and ((group == "a" and is_group_a) or (group == "b" and is_group_b)) %}
-                    {{ course_row(summary_course, row.number) }}
-                    {% set row.number = row.number + 1 %}
-                  {% endif %}
-                {% endfor %}
-              </tbody>
-            </table>
-        {% endfor %}
-
-        {% if summary_semester in [5, 6] %}
-          {% if summary_semester == 5 %}
-            {% set first_label = "Elective-I" %}
-            {% set second_label = "Elective-II" %}
-            {% set specializations = [
-              {"letter": "A", "name": "System and Core Computing (SCC)", "first": ["342AA1", "342AA8", "342AA9"], "second": ["343AB1", "343AB2", "343AB3", "343AB4", "343AB8"]},
-              {"letter": "B", "name": "Machine Intelligence and Data Science (MIDS)", "first": ["342AA2", "342AA5", "342AA6", "342AA8"], "second": ["343AB1", "342AB2", "342AB7"]},
-              {"letter": "C", "name": "Cyber Security and Connected Systems (CSCS)", "first": ["342AA3", "342AA4", "342AA5", "342AA7"], "second": ["343AB5", "342AB6", "342AB7"]},
-            ] %}
-          {% else %}
-            {% set first_label = "Elective-III" %}
-            {% set second_label = "Elective-IV" %}
-            {% set specializations = [
-              {"letter": "A", "name": "System and Core Computing (SCC)", "first": ["342BA1", "342BA2", "342BA3"], "second": ["343BB1", "343BB3", "343BB5", "343BB10"]},
-              {"letter": "B", "name": "Machine Intelligence and Data Science (MIDS)", "first": ["342BA2", "342BA3", "342BA4", "342BA7", "342BA10"], "second": ["343BB2", "343BB4", "343BB7", "343BB9", "343BB10"]},
-              {"letter": "C", "name": "Cyber Security and Connected Systems (CSCS)", "first": ["342BA5", "342BA6", "342BA7", "342BA8"], "second": ["343BB6", "343BB7", "343BB8", "343BB9", "343BB11", "343BB12"]},
-            ] %}
-          {% endif %}
-          <table class="meta summary-table specialization-table">
-            <colgroup>
-              <col class="summary-number" />
-              <col />
-              <col class="summary-title-column" />
-              <col class="summary-title-column" />
-            </colgroup>
-            <tbody>
-              <tr>
-                <th colspan="4" class="center">ELECTIVES TO BE OPTED FOR SPECIALIZATION</th>
-              </tr>
-              <tr>
-                <th class="center">Sl. No.</th>
-                <th>Specialization</th>
-                <th>{{ first_label }}</th>
-                <th>{{ second_label }}</th>
-              </tr>
-              {% for specialization in specializations %}
-                <tr>
-                  <td class="center">{{ specialization.letter }}</td>
-                  <td>{{ specialization.name }}</td>
-                  <td>{{ specialization_codes(specialization.first, summary_semester, curriculum_year) }}</td>
-                  <td>{{ specialization_codes(specialization.second, summary_semester, curriculum_year) }}</td>
-                </tr>
-              {% endfor %}
-            </tbody>
-          </table>
-        {% endif %}
-      </article>
-    {% endif %}
-  {% endif %}
-{% endfor %}

docs/index.md

@@ -1,184 +0,0 @@
----
-title: PESU Curriculum Automation
-permalink: /
----
-
-# PESU Curriculum Automation
-
-PESU Curriculum Automation is a FastAPI and static frontend application for collecting course submissions, refining them into curriculum-ready records, previewing PDF output, staging reviewable edits, and preserving curriculum snapshots.
-
-## System Overview
-
-| Layer | Location | Responsibility |
-| --- | --- | --- |
-| Static frontend | `frontend/` | Course entry, course management, PDF preview, live editor, and version history |
-| API backend | `backend/app/` | FastAPI routes, validation, refinement, previews, drafts, chat, and snapshots |
-| Persistence | Supabase | Raw submissions, refined courses, agent drafts, chat history, attachments, and curriculum versions |
-| Rendering | Jinja2 and WeasyPrint | Curriculum summary pages, course detail pages, and PDF exports |
-| Model provider | OpenRouter | Submission refinement and live editor chat with tool calls |
-
-## Runtime Flow
-
-1. Faculty submit raw course data through `frontend/form/`.
-2. `POST /api/submissions` validates the payload and stores it in `submissions`.
-3. A background refinement task builds deterministic academic fields, calls the model for prose fields, and writes `refined_submissions`.
-4. Course management and preview pages read refined records through `/api/courses` and `/api/preview/*`.
-5. The live editor can edit JSON fields directly or create draft changes through agent tools.
-6. Drafts are reviewed with generated diffs before being applied to refined records.
-7. Version snapshots store complete curriculum states and can restore a prior snapshot.
-
-## Frontend Surfaces
-
-| Route | Purpose |
-| --- | --- |
-| `/` | Dashboard for the available application surfaces |
-| `/form/` | Raw course submission form |
-| `/courses/` | Refined course list with filtering and soft delete |
-| `/preview/` | Overall or semester PDF preview and download |
-| `/live-editor/` | Course preview, chat assistant, JSON editor, draft review, and version restore |
-| `/versions/` | Snapshot list, snapshot preview, and editor handoff |
-
-The frontend is plain HTML, CSS, and JavaScript. There is no Node build step.
-
-## API Surface
-
-| Endpoint | Method | Purpose |
-| --- | --- | --- |
-| `/api/submissions` | `POST` | Store a raw submission and queue refinement |
-| `/api/submissions/{id}/refine` | `POST` | Manually refine a submission |
-| `/api/refined/{refined_id}` | `GET` | Read template-ready course fields |
-| `/api/refined/{refined_id}` | `PATCH` | Update editable refined fields |
-| `/api/courses` | `GET` | List active refined courses |
-| `/api/courses/{refined_id}` | `DELETE` | Archive a refined course |
-| `/api/preview/course/{refined_id}` | `GET` | Render one course as HTML |
-| `/api/preview/pdf` | `GET` | Render the full curriculum as PDF |
-| `/api/preview/semester/{sem}/pdf` | `GET` | Render one semester as PDF |
-| `/api/versions` | `GET`, `POST` | List or create curriculum snapshots |
-| `/api/versions/{version_id}/restore` | `POST` | Restore a saved curriculum snapshot |
-| `/api/agent/drafts` | `GET`, `POST` | List or create reviewable course drafts |
-| `/api/agent/drafts/{draft_id}/apply` | `POST` | Apply a proposed draft after review |
-| `/api/agent/document-drafts` | `GET`, `POST` | List or create multi-course drafts |
-| `/api/chat/sessions` | `GET`, `POST` | Manage live editor chat sessions |
-| `/api/chat/sessions/{session_id}/messages` | `GET`, `POST` | Read or stream chat messages |
-| `/api/chat/sessions/{session_id}/attachments` | `POST` | Upload document context for chat |
-| `/api/health/schema` | `GET` | Check required Supabase tables |
-
-## Submission Contract
-
-`CourseSubmission` is defined in `backend/app/models/submission.py`.
-
-Required fields:
-
-- `faculty_email`
-- `course_title`
-- `offering_department`: `MA`, `CS`, or `UZ`
-- `target_department`: `CSE`, `ECE`, `ME`, `BT`, `EEE`, or `AIML`
-- `semester`: string value from `1` to `8`
-- `credit_category`: `0`, `2`, `4`, or `5`
-- `raw_course_content`: at least 50 characters
-- `text_books`: at least 5 characters
-
-Optional fields:
-
-- `reference_books`
-- `preferred_tools`
-
-Successful submissions return `message` and the inserted `submission` row.
-
-Validation errors use FastAPI's standard `422` response with a `detail` array.
-
-## Deterministic Fields
-
-The backend computes these fields in `backend/app/services/deterministic.py`:
-
-| Credit category | L | T | P | S | C | Course type |
-| --- | ---: | ---: | ---: | ---: | ---: | --- |
-| `5` | 4 | 0 | 2 | 5 | 5 | Core Course-Lab Integrated |
-| `4` | 4 | 0 | 0 | 4 | 4 | Core Course |
-| `2` | 2 | 0 | 0 | 2 | 2 | Core Theory |
-| `0` | 0 | 0 | 0 | 0 | 0 | Foundation Course |
-
-All configured target departments currently map to `B. TECH`.
-
-Agent drafts are not allowed to change deterministic fields such as program, hours, credits, or course type. Drafts that attempt these changes are blocked.
-
-## Database
-
-Run `docs/schema.sql` in the Supabase SQL editor before using the application. The schema creates:
-
-- `submissions`
-- `refined_submissions`
-- `curriculum_versions`
-- `finalized_submissions`
-- `agent_document_drafts`
-- `agent_drafts`
-- `course_revision_history`
-- `chat_sessions`
-- `chat_messages`
-- `chat_attachments`
-
-Use `GET /api/health/schema` to verify that the required tables exist.
-
-## Environment
-
-Required backend variables:
-
-- `SUPABASE_URL`
-- `SUPABASE_KEY`
-- `OPENROUTER_URL`
-- `OPENROUTER_API_KEY`
-- `OPENROUTER_MODEL`
-
-Optional backend variables:
-
-- `CURRICULUM_YEAR`
-- `SENTRY_DSN`
-- `SENTRY_ENVIRONMENT`
-- `SENTRY_RELEASE`
-
-Keep environment values in `.env` or platform secrets. Do not expose backend credentials in frontend code.
-
-## Local Development
-
-```bash
-python3 -m venv .venv
-source .venv/bin/activate
-pip install -r requirements.txt
-cd backend
-fastapi dev app/main.py
-```
-
-The backend serves the static frontend at `http://127.0.0.1:8000/` and mounts the API under `/api`.
-
-Run checks from the repository root:
-
-```bash
-source .venv/bin/activate
-pytest
-python3 -m compileall backend/app
-```
-
-## Deployment
-
-The Docker image installs the Python dependencies, copies `backend/` and `frontend/`, and runs:
-
-```bash
-uvicorn app.main:app --host 0.0.0.0 --port 7860
-```
-
-The included GitHub Actions workflow syncs `main` to the Hugging Face Space configured in `.github/workflows/sync-to-hub.yml`.
-
-The static frontend can also be deployed from `frontend/`. The included `frontend/vercel.json` rewrites `/api/*` requests to the deployed backend.
-
-## Current Checks
-
-The test suite covers:
-
-- Deterministic credit, hour, program, and course type mapping
-- Submission refinement helpers
-- Preview rendering and curriculum summary behavior
-- Agent diffing, protected field checks, and draft tooling
-- OpenRouter streaming and error handling
-- Static frontend route structure
-- Supabase schema status checks
-- Attachment extraction safeguards and text/DOCX parsing

docs/remote-db.md

@@ -1,44 +0,0 @@
-# Remote Database Access
-
-This project uses Supabase as the remote database. The backend client is configured in `backend/app/supabase.py` and reads credentials from the repo root `.env` file.
-
-## Required Access
-
-Ask the project owner for:
-
-- Supabase dashboard access.
-- The backend `SUPABASE_URL`.
-- The backend `SUPABASE_KEY`.
-
-Keep these values in `.env` only. Do not commit credentials or paste them into frontend code.
-
-## Current Data Flow
-
-- `submissions` stores the raw form input.
-- `refined_submissions` stores the template-ready refined fields used by the preview template.
-- `agent_drafts` and `agent_document_drafts` store proposed AI changes before human approval.
-- `finalized_submissions` and `curriculum_versions` store approved curriculum snapshots.
-
-## Schema
-
-Run `docs/schema.sql` in the Supabase SQL editor to create the public project tables. This file is schema-only: it does not rename tables, backfill data, or insert test rows.
-
-## Read Data From Code
-
-Run these commands from the repo root after `.env` is configured:
-
-```bash
-source .venv/bin/activate
-cd backend
-python3 - <<'PY'
-from app.supabase import supabase
-
-raw = supabase.table("submissions").select("id,course_title,status,semester").limit(5).execute()
-refined = supabase.table("refined_submissions").select("id,submission_id,course_title,semester").limit(5).execute()
-
-print("submissions")
-print(raw.data)
-print("refined_submissions")
-print(refined.data)
-PY
-```

docs/schema.sql

@@ -1,149 +0,0 @@
-create table if not exists submissions (
-  id bigint generated by default as identity primary key,
-  faculty_email text not null,
-  course_title text not null,
-  offering_department text not null check (offering_department in ('MA', 'CS', 'UZ')),
-  target_department text not null check (target_department in ('CSE', 'ECE', 'ME', 'BT', 'EEE', 'AIML')),
-  semester integer not null check (semester between 1 and 8),
-  credit_category text not null check (credit_category in ('0', '2', '4', '5')),
-  raw_course_content text not null,
-  text_books text not null,
-  reference_books text not null default '',
-  preferred_tools text not null default '',
-  status text not null default 'pending',
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists refined_submissions (
-  id bigint generated by default as identity primary key,
-  submission_id bigint not null unique references submissions(id) on delete cascade,
-  semester integer not null check (semester between 1 and 8),
-  course_code text not null default '',
-  course_title text not null,
-  program text not null,
-  lecture_hours integer not null default 0,
-  tutorial_hours integer not null default 0,
-  practical_hours integer not null default 0,
-  self_study integer not null default 0,
-  credits integer not null default 0,
-  course_type text not null,
-  tools_languages text not null default '',
-  desirable_knowledge text not null default '',
-  prelude text not null default '',
-  objectives text[] not null default '{}',
-  course_outcomes text[] not null default '{}',
-  units jsonb not null default '[]'::jsonb check (jsonb_typeof(units) = 'array'),
-  lab_experiments text[] not null default '{}',
-  text_books text[] not null default '{}',
-  reference_books text[] not null default '{}',
-  status text not null default 'refined',
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists curriculum_versions (
-  id bigint generated by default as identity primary key,
-  name text not null,
-  program text not null,
-  academic_year text not null,
-  status text not null default 'draft' check (status in ('draft', 'published', 'archived')),
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists finalized_submissions (
-  id bigint generated by default as identity primary key,
-  curriculum_version_id bigint not null references curriculum_versions(id) on delete cascade,
-  refined_id bigint not null references refined_submissions(id) on delete restrict,
-  course_json jsonb not null check (jsonb_typeof(course_json) = 'object'),
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now(),
-  unique (curriculum_version_id, refined_id)
-);
-
-create table if not exists agent_document_drafts (
-  id bigint generated by default as identity primary key,
-  curriculum_version_id bigint references curriculum_versions(id) on delete set null,
-  uploaded_document_id text not null default '',
-  diff_summary jsonb not null default '{}'::jsonb check (jsonb_typeof(diff_summary) = 'object'),
-  change_reason text not null default '',
-  status text not null default 'proposed' check (status in ('proposed', 'blocked', 'approved', 'rejected', 'applied')),
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists agent_drafts (
-  id bigint generated by default as identity primary key,
-  refined_id bigint not null references refined_submissions(id) on delete cascade,
-  document_draft_id bigint references agent_document_drafts(id) on delete cascade,
-  base_refined_json jsonb not null check (jsonb_typeof(base_refined_json) = 'object'),
-  proposed_json jsonb not null check (jsonb_typeof(proposed_json) = 'object'),
-  json_patch jsonb not null default '[]'::jsonb check (jsonb_typeof(json_patch) = 'array'),
-  diff_summary jsonb not null default '{}'::jsonb check (jsonb_typeof(diff_summary) = 'object'),
-  change_reason text not null default '',
-  status text not null default 'proposed' check (status in ('proposed', 'blocked', 'approved', 'rejected', 'applied')),
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists course_revision_history (
-  id bigint generated by default as identity primary key,
-  refined_id bigint not null references refined_submissions(id) on delete cascade,
-  agent_draft_id bigint references agent_drafts(id) on delete set null,
-  source text not null default 'agent_draft',
-  previous_json jsonb not null check (jsonb_typeof(previous_json) = 'object'),
-  next_json jsonb not null check (jsonb_typeof(next_json) = 'object'),
-  json_patch jsonb not null default '[]'::jsonb check (jsonb_typeof(json_patch) = 'array'),
-  diff_summary jsonb not null default '{}'::jsonb check (jsonb_typeof(diff_summary) = 'object'),
-  change_reason text not null default '',
-  changed_by text not null default '',
-  created_at timestamptz not null default now()
-);
-
-create table if not exists chat_sessions (
-  id bigint generated by default as identity primary key,
-  refined_id bigint references refined_submissions(id) on delete set null,
-  document_draft_id bigint references agent_document_drafts(id) on delete set null,
-  title text not null default '',
-  status text not null default 'active' check (status in ('active', 'archived')),
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists chat_messages (
-  id bigint generated by default as identity primary key,
-  session_id bigint not null references chat_sessions(id) on delete cascade,
-  role text not null check (role in ('user', 'assistant', 'system', 'tool')),
-  content text not null default '',
-  metadata jsonb not null default '{}'::jsonb check (jsonb_typeof(metadata) = 'object'),
-  created_at timestamptz not null default now()
-);
-
-create table if not exists chat_attachments (
-  id bigint generated by default as identity primary key,
-  session_id bigint not null references chat_sessions(id) on delete cascade,
-  message_id bigint references chat_messages(id) on delete set null,
-  filename text not null,
-  content_type text not null default '',
-  size_bytes integer not null default 0,
-  extracted_text text not null default '',
-  status text not null default 'ready' check (status in ('ready', 'unsupported', 'failed')),
-  error text not null default '',
-  created_at timestamptz not null default now()
-);
-
-create index if not exists submissions_semester_idx on submissions (semester);
-create index if not exists submissions_status_idx on submissions (status);
-create index if not exists refined_submissions_semester_idx on refined_submissions (semester);
-create index if not exists agent_drafts_refined_id_idx on agent_drafts (refined_id);
-create index if not exists agent_drafts_document_draft_id_idx on agent_drafts (document_draft_id);
-create index if not exists agent_drafts_status_idx on agent_drafts (status);
-create index if not exists agent_document_drafts_status_idx on agent_document_drafts (status);
-create index if not exists finalized_submissions_curriculum_version_idx on finalized_submissions (curriculum_version_id);
-create index if not exists course_revision_history_refined_id_idx on course_revision_history (refined_id);
-create index if not exists chat_sessions_refined_id_idx on chat_sessions (refined_id);
-create index if not exists chat_sessions_document_draft_id_idx on chat_sessions (document_draft_id);
-create index if not exists chat_messages_session_id_idx on chat_messages (session_id, created_at);
-create index if not exists chat_attachments_session_id_idx on chat_attachments (session_id);
-create index if not exists chat_attachments_message_id_idx on chat_attachments (message_id);

frontend/courses.html

@@ -1,2 +0,0 @@
-<!doctype html>
-<meta http-equiv="refresh" content="0;url=courses/" />

frontend/courses/courses.css

@@ -1,130 +0,0 @@
-@import "../shared.css";
-
-* {
-  box-sizing: border-box;
-}
-
-body {
-  margin: 0;
-  min-height: 100dvh;
-  background: var(--page-bg);
-  color: var(--text);
-  font-family: Arial, sans-serif;
-}
-
-.shell {
-  display: grid;
-  gap: 12px;
-  padding: 16px;
-}
-
-.topbar,
-.panel {
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--surface);
-}
-
-.topbar {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 14px;
-}
-
-h1 {
-  margin: 0;
-  color: var(--pesu-blue);
-  font-size: 22px;
-}
-
-p {
-  margin: 4px 0 0;
-  color: var(--muted);
-  font-size: 13px;
-}
-
-.actions,
-.filters {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  min-width: 0;
-}
-
-.filters {
-  padding: 12px;
-  border-bottom: 1px solid var(--border);
-}
-
-.filters input {
-  flex: 1;
-}
-
-#status {
-  margin-left: auto;
-}
-
-.table-wrap {
-  overflow: auto;
-}
-
-table {
-  width: 100%;
-  border-collapse: collapse;
-}
-
-th,
-td {
-  padding: 10px 12px;
-  border-bottom: 1px solid var(--border);
-  text-align: left;
-  vertical-align: top;
-  font-size: 14px;
-}
-
-th {
-  color: var(--pesu-blue);
-  background: #f8fafc;
-  font-size: 12px;
-  text-transform: uppercase;
-}
-
-.course-row {
-  cursor: pointer;
-}
-
-.course-row:hover {
-  background: #f8fafc;
-}
-
-.details {
-  display: grid;
-  gap: 8px;
-  color: #374151;
-  line-height: 1.45;
-}
-
-.details strong {
-  color: var(--pesu-blue);
-}
-
-.empty {
-  padding: 20px;
-  color: var(--muted);
-  text-align: center;
-}
-
-@media (max-width: 760px) {
-  .topbar,
-  .actions,
-  .filters {
-    align-items: stretch;
-    flex-direction: column;
-  }
-
-  #status {
-    margin-left: 0;
-  }
-}

frontend/courses/courses.js

@@ -1,117 +0,0 @@
-const semester = document.getElementById("semester");
-const search = document.getElementById("search");
-const statusText = document.getElementById("status");
-const table = document.getElementById("course-table");
-let courses = [];
-let openId = "";
-
-function setStatus(text, kind = "") {
-  statusText.textContent = text;
-  statusText.className = `status-line ${kind}`.trim();
-}
-
-function cell(text) {
-  const td = document.createElement("td");
-  td.textContent = text || "";
-  return td;
-}
-
-function courseMatches(course) {
-  const query = search.value.trim().toLowerCase();
-  if (semester.value && String(course.semester) !== semester.value) return false;
-  if (!query) return true;
-  return `${course.course_code} ${course.course_title}`.toLowerCase().includes(query);
-}
-
-function detailsRow(course) {
-  const row = document.createElement("tr");
-  const td = document.createElement("td");
-  td.colSpan = 5;
-  const details = document.createElement("div");
-  details.className = "details";
-  details.append(
-    line("Type", course.course_type),
-    line("Tools", course.tools_languages || "Not specified"),
-    line("Desirable knowledge", course.desirable_knowledge || "None"),
-    line("Prelude", course.prelude || "Not specified"),
-  );
-  td.appendChild(details);
-  row.appendChild(td);
-  return row;
-}
-
-function line(label, value) {
-  const div = document.createElement("div");
-  const strong = document.createElement("strong");
-  strong.textContent = `${label}: `;
-  div.append(strong, document.createTextNode(value));
-  return div;
-}
-
-function render() {
-  table.replaceChildren();
-  const visible = courses.filter(courseMatches);
-  if (!visible.length) {
-    const row = document.createElement("tr");
-    const td = document.createElement("td");
-    td.colSpan = 5;
-    td.className = "empty";
-    td.textContent = "No courses found.";
-    row.appendChild(td);
-    table.appendChild(row);
-    setStatus("No courses found.");
-    return;
-  }
-
-  visible.forEach((course) => {
-    const row = document.createElement("tr");
-    row.className = "course-row";
-    row.append(cell(course.semester), cell(course.course_code), cell(course.course_title), cell(course.credits));
-
-    const action = document.createElement("td");
-    const remove = document.createElement("button");
-    remove.type = "button";
-    remove.className = "danger";
-    remove.textContent = "Delete";
-    remove.addEventListener("click", (event) => {
-      event.stopPropagation();
-      deleteCourse(course);
-    });
-    action.appendChild(remove);
-    row.appendChild(action);
-
-    row.addEventListener("click", () => {
-      openId = openId === String(course.id) ? "" : String(course.id);
-      render();
-    });
-    table.appendChild(row);
-    if (openId === String(course.id)) table.appendChild(detailsRow(course));
-  });
-  setStatus(`${visible.length} course${visible.length === 1 ? "" : "s"}.`, "ready");
-}
-
-async function deleteCourse(course) {
-  if (!confirm(`Delete ${course.course_code || course.course_title}?`)) return;
-  setStatus("Deleting course...");
-  const response = await fetch(`/api/courses/${course.id}`, { method: "DELETE" });
-  if (!response.ok) throw new Error("Delete failed");
-  courses = courses.filter((item) => item.id !== course.id);
-  if (openId === String(course.id)) openId = "";
-  render();
-}
-
-async function loadCourses() {
-  setStatus("Loading courses...");
-  const response = await fetch("/api/courses");
-  if (!response.ok) throw new Error("Unable to load courses");
-  const body = await response.json();
-  courses = body.courses || [];
-  render();
-}
-
-semester.addEventListener("change", render);
-search.addEventListener("input", render);
-
-loadCourses().catch((error) => {
-  setStatus(error instanceof Error ? error.message : "Unable to load courses.", "error");
-});

frontend/courses/index.html

@@ -1,57 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Course Management</title>
-    <link rel="stylesheet" href="courses.css" />
-    <script src="courses.js" defer></script>
-  </head>
-  <body>
-    <main class="shell">
-      <header class="topbar">
-        <div>
-          <h1>Course Management</h1>
-          <p>Manage refined courses used by preview, editor, and versions.</p>
-        </div>
-        <div class="actions">
-          <a class="button-link" href="../form/">Add Course</a>
-          <a class="button-link" href="../live-editor/">Live Editor</a>
-        </div>
-      </header>
-
-      <section class="panel">
-        <div class="filters">
-          <select id="semester" aria-label="Semester">
-            <option value="">All semesters</option>
-            <option value="1">Semester 1</option>
-            <option value="2">Semester 2</option>
-            <option value="3">Semester 3</option>
-            <option value="4">Semester 4</option>
-            <option value="5">Semester 5</option>
-            <option value="6">Semester 6</option>
-            <option value="7">Semester 7</option>
-            <option value="8">Semester 8</option>
-          </select>
-          <input id="search" type="search" aria-label="Search courses" />
-          <span class="status-line" id="status"></span>
-        </div>
-
-        <div class="table-wrap">
-          <table>
-            <thead>
-              <tr>
-                <th>Semester</th>
-                <th>Code</th>
-                <th>Course</th>
-                <th>Credits</th>
-                <th></th>
-              </tr>
-            </thead>
-            <tbody id="course-table"></tbody>
-          </table>
-        </div>
-      </section>
-    </main>
-  </body>
-</html>

frontend/form.html

@@ -1,11 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta http-equiv="refresh" content="0;url=form/" />
-    <title>Course Submission - PESU</title>
-  </head>
-  <body>
-    <a href="form/">Course Submission</a>
-  </body>
-</html>

frontend/form/index.html

@@ -1,100 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Course Submission - PESU</title>
-    <link rel="stylesheet" href="form.css" />
-    <script src="form.js" defer></script>
-  </head>
-  <body>
-    <div class="container">
-      <div class="card">
-        <h1>Course Submission</h1>
-        <p class="subtitle">Fill in the course details below.</p>
-
-        <form id="course-form">
-          <fieldset>
-            <legend>Faculty Details</legend>
-
-            <label for="faculty_email">Email</label>
-            <input type="email" id="faculty_email" name="faculty_email" required />
-
-            <label for="offering_department">Offering Department</label>
-
-            <select id="offering_department" name="offering_department" required>
-              <option value="">Select offering department</option>
-              <option value="MA">Mathematics (MA)</option>
-              <option value="CS">Computer Science (CS)</option>
-              <option value="UZ">(UZ)</option>
-            </select>
-
-            <span class="hint">e.g. Mathematics, Computer Science (MA, CS)</span>
-          </fieldset>
-
-          <fieldset>
-            <legend>Course Details</legend>
-
-            <label for="target_department">Target Department / Program</label>
-            <select id="target_department" name="target_department" required>
-              <option value="">Select target department</option>
-              <option value="CSE">Computer Science and Engineering (CSE)</option>
-              <option value="AIML">Artificial Intelligence and Machine Learning (AIML)</option>
-              <option value="ECE">Electronics and Communication Engineering (ECE)</option>
-              <option value="ME">Mechanical Engineering (ME)</option>
-              <option value="EEE">Electronics and Electrical Engineering (EEE)</option>
-              <option value="BT">Biotechnology (BT)</option>
-            </select>
-
-            <label for="semester">Semester</label>
-            <select id="semester" name="semester" required>
-              <option value="">Select semester</option>
-              <option value="1">Semester 1</option>
-              <option value="2">Semester 2</option>
-              <option value="3">Semester 3</option>
-              <option value="4">Semester 4</option>
-              <option value="5">Semester 5</option>
-              <option value="6">Semester 6</option>
-              <option value="7">Semester 7</option>
-              <option value="8">Semester 8</option>
-            </select>
-
-            <label for="course_title">Course Title</label>
-            <input type="text" id="course_title" name="course_title" required />
-
-            <label for="credit_category">Credit Category</label>
-            <select id="credit_category" name="credit_category" required>
-              <option value="">Select credit category</option>
-              <option value="0">0 Credits</option>
-              <option value="2">2 Credits</option>
-              <option value="4">4 Credits</option>
-              <option value="5">5 Credits</option>
-            </select>
-          </fieldset>
-
-          <fieldset>
-            <legend>Academic Content</legend>
-            <label for="raw_course_content">Course Content</label>
-            <textarea id="raw_course_content" name="raw_course_content" rows="8" required></textarea>
-            <span class="hint">Topics, units, or rough syllabus.</span>
-
-            <label for="text_books">Textbook References</label>
-            <textarea id="text_books" name="text_books" rows="4" required></textarea>
-
-            <label for="reference_books">Other Suggested Reference Books <span class="optional">(optional)</span></label>
-            <textarea id="reference_books" name="reference_books" rows="4"></textarea>
-
-            <label for="preferred_tools">Preferred Tools / Languages <span class="optional">(optional)</span></label>
-            <textarea id="preferred_tools" name="preferred_tools" rows="3"></textarea>
-          </fieldset>
-
-          <button type="submit" id="submit-btn">Submit Course</button>
-          <a class="form-link" href="../courses/">Manage Courses</a>
-          <a class="form-link" href="../preview/">View Preview</a>
-        </form>
-
-        <div id="result" class="hidden"></div>
-      </div>
-    </div>
-  </body>
-</html>

frontend/home/home.css

@@ -1,70 +0,0 @@
-@import "../shared.css";
-
-*, *::before, *::after {
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-}
-
-:root {
-  --bg: var(--page-bg);
-  --text: var(--pesu-blue);
-  --accent: var(--pesu-orange);
-}
-
-body {
-  min-height: 100dvh;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 1rem;
-  background: var(--bg);
-  color: var(--text);
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
-}
-
-.home-shell {
-  width: 100%;
-  max-width: 760px;
-}
-
-.home-panel {
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: 12px;
-  padding: 2rem;
-}
-
-h1 {
-  font-size: 1.5rem;
-}
-
-.surface-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
-  gap: 1rem;
-  margin-top: 1.5rem;
-}
-
-.surface-link {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 96px;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  color: var(--text);
-  background: var(--surface);
-  text-decoration: none;
-  font-weight: 700;
-}
-
-.surface-link:hover {
-  border-color: var(--accent);
-}
-
-@media (max-width: 640px) {
-  .surface-grid {
-    grid-template-columns: 1fr;
-  }
-}

frontend/index.html

@@ -3,21 +3,97 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>PESU Curriculum Automation</title>
-    <link rel="stylesheet" href="home/home.css" />
+    <title>Course Submission — PESU</title>
+    <link rel="stylesheet" href="styles.css" />
+    <script src="script.js" defer></script>
   </head>
   <body>
-    <main class="home-shell">
-      <section class="home-panel">
-        <h1>PESU Curriculum Automation</h1>
-        <nav class="surface-grid" aria-label="Curriculum surfaces">
-          <a class="surface-link" href="form/">Raw Data</a>
-          <a class="surface-link" href="courses/">Courses</a>
-          <a class="surface-link" href="preview/">Preview</a>
-          <a class="surface-link" href="live-editor/">Live Editor</a>
-          <a class="surface-link" href="versions/">Versions</a>
-        </nav>
-      </section>
-    </main>
+    <div class="container">
+      <div class="card">
+        <h1>Course Submission</h1>
+        <p class="subtitle">Fill in the course details below.</p>
+
+        <form id="course-form">
+          <fieldset>
+            <legend>Faculty Details</legend>
+
+            <label for="faculty_email">Email</label>
+            <input type="email" id="faculty_email" name="faculty_email" required />
+
+            <label for="offering_department">Offering Department</label>
+
+            <select id="offering_department" name="offering_department" required>
+              <option value="">Select offering department</option>
+              <option value="MA">Mathematics (MA)</option>
+              <option value="CS">Computer Science (CS)</option>
+              <option value="UZ">(UZ)</option>
+            </select>
+
+            <span class="hint">e.g. Mathematics, Computer Science (MA, CS)</span>
+
+          </fieldset>
+
+          <fieldset>
+            <legend>Course Details</legend>
+
+            <label for="target_department">Target Department / Program</label>
+            <select id="target_department" name="target_department" required>
+              <option value="">Select target department</option>
+              <option value="CSE">Computer Science and Engineering (CSE)</option>
+              <option value="AIML">Artificial Intelligence and Machine Learning (AIML)</option>
+              <option value="ECE">Electronics and Communication Engineering (ECE)</option>
+              <option value="ME">Mechanical Engineering (ME)</option>
+              <option value="EEE">Electronics and Electrical Engineering (EEE)</option>
+              <option value="BT">Biotechnology (BT)</option>
+            </select>
+          
+            <label for="semester">Semester</label>
+            <select id="semester" name="semester" required>
+              <option value="">Select semester</option>
+              <option value="1">Semester 1</option>
+              <option value="2">Semester 2</option>
+              <option value="3">Semester 3</option>
+              <option value="4">Semester 4</option>
+              <option value="5">Semester 5</option>
+              <option value="6">Semester 6</option>
+              <option value="7">Semester 7</option>
+              <option value="8">Semester 8</option>
+            </select>
+
+            <label for="course_title">Course Title</label>
+            <input type="text" id="course_title" name="course_title" required />
+
+            <label for="credit_category">Credit Category</label>
+            <select id="credit_category" name="credit_category" required>
+              <option value="">Select credit category</option>
+              <option value="0">0 Credits</option>
+              <option value="2">2 Credits</option>
+              <option value="4">4 Credits</option>
+              <option value="5">5 Credits</option>
+            </select>
+          </fieldset>
+
+          <fieldset>
+            <legend>Academic Content</legend>
+            <label for="raw_course_content">Course Content</label>
+            <textarea id="raw_course_content" name="raw_course_content" rows="8" required></textarea>
+            <span class="hint">Topics, units, or rough syllabus.</span>
+
+            <label for="text_books">Textbook References</label>
+            <textarea id="text_books" name="text_books" rows="4" required></textarea>
+
+            <label for="reference_books">Other Suggested Reference Books <span class="optional">(optional)</span></label>
+            <textarea id="reference_books" name="reference_books" rows="4"></textarea>
+
+            <label for="preferred_tools">Preferred Tools / Languages <span class="optional">(optional)</span></label>
+            <textarea id="preferred_tools" name="preferred_tools" rows="3"></textarea>
+          </fieldset>
+
+          <button type="submit" id="submit-btn">Submit Course</button>
+        </form>
+
+        <div id="result" class="hidden"></div>
+      </div>
+    </div>
   </body>
 </html>

frontend/live-editor.html

@@ -1,11 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta http-equiv="refresh" content="0;url=live-editor/" />
-    <title>Live Editor - PESU</title>
-  </head>
-  <body>
-    <a href="live-editor/">Live Editor</a>
-  </body>
-</html>

frontend/live-editor/index.html

@@ -1,112 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Live Editor - PESU</title>
-    <link rel="stylesheet" href="live-editor.css" />
-  </head>
-  <body>
-    <header class="toolbar">
-      <div class="toolbar-group course-controls">
-        <select id="semester" aria-label="Semester">
-          <option value="1">Semester 1</option>
-          <option value="2">Semester 2</option>
-          <option value="3">Semester 3</option>
-          <option value="4">Semester 4</option>
-          <option value="5">Semester 5</option>
-          <option value="6">Semester 6</option>
-          <option value="7">Semester 7</option>
-          <option value="8">Semester 8</option>
-        </select>
-        <select id="course" aria-label="Course"></select>
-        <select id="view-mode" aria-label="Preview mode">
-          <option value="course">Course Preview</option>
-          <option value="document">Full Document</option>
-        </select>
-        <a class="button-link" id="preview" target="_blank" rel="noreferrer">Open</a>
-      </div>
-
-      <div class="toolbar-group version-controls">
-        <input id="version-name" type="text" aria-label="Version name" />
-        <button id="save-version" type="button">Save Version</button>
-        <select id="version-select" aria-label="Saved version"></select>
-        <button id="restore-version" type="button">Restore</button>
-      </div>
-
-      <span class="status-line" id="status" role="status" hidden></span>
-    </header>
-
-    <main class="workspace">
-      <section class="preview-pane" aria-label="Course preview">
-        <iframe id="viewer" title="Course preview"></iframe>
-        <div class="loading" id="loading">Loading...</div>
-      </section>
-
-      <aside class="side-pane">
-        <div class="tabs" role="tablist" aria-label="Editor tools">
-          <button class="tab active" id="chat-tab" type="button" role="tab" aria-selected="true" aria-controls="chat-panel">Chat</button>
-          <button class="tab" id="fields-tab" type="button" role="tab" aria-selected="false" aria-controls="fields-panel">Fields</button>
-          <button class="tab" id="review-tab" type="button" role="tab" aria-selected="false" aria-controls="review-panel">Review</button>
-        </div>
-
-        <section class="panel chat-panel active" id="chat-panel" role="tabpanel" aria-labelledby="chat-tab">
-          <div class="thread-bar">
-            <div class="thread-selector">
-              <select id="chat-session" aria-label="Chat thread"></select>
-              <button id="rename-chat" type="button" class="icon-btn" title="Rename thread">
-                <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                  <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
-                  <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" />
-                </svg>
-              </button>
-            </div>
-            <input id="chat-title" type="text" aria-label="Chat title" hidden />
-            <button class="danger" id="delete-chat" type="button">Delete</button>
-            <button id="new-chat" type="button">New</button>
-          </div>
-          <div class="chat-status" id="chat-status" role="status"></div>
-          <div class="chat-log" id="chat-log" aria-live="polite"></div>
-          <div class="composer">
-            <div class="attachments" id="draft-attachments"></div>
-            <textarea id="message" aria-label="Message"></textarea>
-            <div class="composer-actions">
-              <button id="attach" type="button">Attach</button>
-              <input id="files" type="file" multiple accept="image/*,.pdf,.txt,.doc,.docx" hidden />
-              <button class="primary" id="send" type="button">Send</button>
-            </div>
-          </div>
-        </section>
-
-        <section class="panel fields-panel" id="fields-panel" role="tabpanel" aria-labelledby="fields-tab">
-          <textarea id="editor" spellcheck="false" aria-label="Course fields"></textarea>
-          <div class="field-actions">
-            <button id="draft" type="button">Create Draft</button>
-            <button class="primary" id="save" type="button">Save</button>
-          </div>
-        </section>
-
-        <section class="panel review-panel" id="review-panel" role="tabpanel" aria-labelledby="review-tab">
-          <div class="document-draft">
-            <div class="draft-loader">
-              <select id="course-draft-select" aria-label="Course draft"></select>
-              <button id="load-course-draft" type="button" title="Load single‑course draft from agent">Load Course</button>
-            </div>
-            <div class="draft-loader">
-              <select id="document-draft-select" aria-label="Document draft"></select>
-              <button id="load-document-draft" type="button" title="Load multi‑course document draft from agent">Load Document</button>
-            </div>
-          </div>
-          <div class="review-summary" id="review-summary"></div>
-          <div class="diff-view" id="diff-view"></div>
-          <div class="field-actions">
-            <button id="preview-draft" type="button">Preview Draft</button>
-            <button class="primary" id="apply-draft" type="button">Apply Draft</button>
-          </div>
-        </section>
-      </aside>
-    </main>
-
-    <script src="live-editor.js" defer></script>
-  </body>
-</html>