+
+
+
+
+ Syntagma
+ +Sign in to continue
+{{ SEMESTER_NAMES[summary_semester|string] }} SEMESTER {{ batch_label(summary_semester, curriculum_year) }}
+| Sl. No. | +Course Code | +Course Title | +Hours per week | +Credits | +AI Tools / Tools / Languages |
+ Course Type | +|||
|---|---|---|---|---|---|---|---|---|---|
| L | +T | +P | +S | +C | +|||||
| Total | +{{ total_cell(totals.lecture, totals.lecture_credit) }} | +{{ totals.tutorial }} | +{{ totals.practical }} | +{{ totals.self_study }} | +{{ totals.credits }} | ++ | + | ||
{{ SEMESTER_NAMES[summary_semester|string] }} SEMESTER {{ batch_label(summary_semester, curriculum_year) }}
+| Sl. No. | +Course Code | +Course Title | +Hours/week | +Credits | +Course Type | +|||
|---|---|---|---|---|---|---|---|---|
| L | +T | +P | +S | +C | +||||
| Total | +{{ totals.lecture }} | +{{ totals.tutorial }} | +{{ totals.practical }} | +{{ totals.self_study }} | +{{ totals.credits }} | ++ | ||
−{{ diff.old }}
+ {% endif %}
+ {% if diff.new != "" %}
+ +{{ diff.new }}
+ {% endif %}
+ {% else %}
+ {{ fallback }}
+ {% endif %}
+ {% endmacro %}
+
+ {% macro diff_cell(diff, proposed_value) %}
+ −{{ diff.old }}
+ {% endif %}
+ {% if diff.new != "" %}
+ +{{ diff.new }}
+ {% endif %}
+ {% else %}
+ {{ proposed_value }}
+ {% endif %}
+ - {% else %}
- {{ item }} + {% endfor %} + {% for item in diff.removed %} +
- −{{ item }} + {% endfor %} + {% for item in diff.added %} +
- +{{ item }} + {% endfor %} + {% if ordered %}
- {% endif %}
+ {% for item in diff.unchanged %}
+
- {% else %}
- {{ item }} + {% endfor %} + {% if ordered %}
- {% endif %}
+ {% for item in proposed_course[field_name] %}
+
+
+ {% elif unit_entry.kind == "added" %}
+ − {{ unit_entry.unit.title }} ({{ unit_entry.unit.hours }} Hours)
+ {{ unit_entry.unit.content }}
+
+
+ {% elif unit_entry.kind == "changed" %}
+ + {{ unit_entry.unit.title }} ({{ unit_entry.unit.hours }} Hours)
+ {{ unit_entry.unit.content }}
+
+
+ {% else %}
+ ~ {{ unit_entry.unit.title }} ({{ unit_entry.unit.hours }} Hours)
+ {{ unit_entry.unit.content }}
+
+ {% for field, change in unit_entry.changes.items() %}
+
+ − {{ field }}: {{ change.old }}
+ + {{ field }}: {{ change.new }}
+ {% endfor %}
+
+
+ {% endif %}
+ {% endfor %}
+ {% else %}
+ {% for unit in proposed_course.units %}
+ {{ unit_entry.unit.title }}
+ {{ unit_entry.unit.content }}
+{{ unit_entry.unit.hours }} Hours
+
+
+ {% endfor %}
+ {% endif %}
+ {% endmacro %}
+
+ {% macro render_course(course_diff, proposed_course) %}
+ {{ unit.title }}
+{{ unit.content }}
+{{ unit.hours }} Hours
+| Course Code | + {{ diff_cell(course_diff.course_code, proposed_course.course_code | course_code_for_year(proposed_course.semester, curriculum_year)) }} +Course Title | +{{ diff_inline(course_diff.course_title, proposed_course.course_title) }} | +|||||
|---|---|---|---|---|---|---|---|
| Program | +{{ proposed_course.program }} | +Hours per week / Credit Assigned | +L | T | P | S | C | +
| {{ proposed_course.lecture_hours }} | +{{ proposed_course.tutorial_hours }} | +{{ proposed_course.practical_hours }} | +{{ proposed_course.self_study }} | +{{ proposed_course.credits }} | +|||
| Semester | +{{ proposed_course.semester }} | +Type of Course | +{{ proposed_course.course_type }} | +||||
| AI Tools / Tools / Languages | + {{ diff_cell(course_diff.tools_languages, proposed_course.tools_languages) }} +Desirable Knowledge | +{{ diff_inline(course_diff.desirable_knowledge, proposed_course.desirable_knowledge) }} | +|||||
| Prelude | +{{ diff_inline(course_diff.prelude, proposed_course.prelude) }} | +
|---|---|
| Course Objectives: | +{{ render_list(course_diff, proposed_course, "objectives") }} | +
| Course Contents | +{{ render_units(course_diff, proposed_course) }} | +
| Laboratory | +{{ render_list(course_diff, proposed_course, "lab_experiments", ordered=true) }} | +
| Text Book(s): | +{{ render_list(course_diff, proposed_course, "text_books", ordered=true) }} | +
| Reference Book(s): | +{{ render_list(course_diff, proposed_course, "reference_books", ordered=true) }} | +
| Course Outcome | +{{ render_list(course_diff, proposed_course, "course_outcomes") }} | +
No diff data available
+ {% endif %}
+
+
\ No newline at end of file
diff --git a/backend/app/templates/jinja_program.html b/backend/app/templates/jinja_program.html
new file mode 100644
index 0000000000000000000000000000000000000000..96401606e85aec313f693846d14e4379ab020dd8
--- /dev/null
+++ b/backend/app/templates/jinja_program.html
@@ -0,0 +1,42 @@
+
+ 
+
+Computer Science and Engineering
+P.E.S. University
+Curriculum :- {{ curriculum_year }}
+Computer Science and Engineering
+B. TECH IN COMPUTER SCIENCE AND ENGINEERING
+ +PROGRAM EDUCATIONAL OBJECTIVES
+-
+
- Prepare and train students in theoretical foundations to work with cutting edge computing technologies and design solutions to complex engineering problems, making them ready to work in industrial environment. +
- Develop all round skills such as team building, inter-personal skills, and leadership qualities in order to effectively communicate with engineering community and with society at large. +
- Promote research culture through internships, research assistantships, research-oriented projects, sponsored and collaborative research and enable them to pursue higher studies in computer science and related fields. +
- To inculcate social concern meeting the requirements of prospective employers and to develop an ability to innovate efficient computing solutions for a better society. +
- Create professionally superior and ethically strong globally competent employees and entrepreneurs. +
PROGRAM OUTCOMES
+-
+
- Apply mathematical and theoretical principles in the modeling and design of high-quality computer-based systems using state-of-the-art computer technology. +
- Conduct in-depth study of research literature in the area of Computer Science, analyse problems in order to arrive at substantiated conclusions using first principles of mathematics, and allied sciences. +
- Design, implement and evaluate Computer Systems, programs and processes that meet partial/ complete specifications with concern for society, environment and culture. +
- Design and conduct experiments, collect data, analyze and interpret the results to investigate complex engineering problems in the field of Computer Science. +
- Apply state-of-the-art techniques and modern computer-based tools in prediction, comparison and modelling of complex engineering activities. +
- Have a sound understanding of professional, legal, security and social issues and responsibilities in engineering activities involving Computer Science. +
- Understand societal and environmental concerns and demonstrate responsibility in sustainable development of computer-based solutions. +
- Be aware of ethical and professional responsibilities in engineering situations; make informed judgments regarding intellectual property and rights in relation to computer-based solutions in global, economic, environmental and societal contexts. +
- Able to function effectively in teams to establish goals, plan tasks, meet deadlines, manage risk and produce high-quality technical solutions. +
- Contribute and communicate effectively with the society, be able to write effective reports and design documents by adhering to appropriate standards, make effective presentations, give and receive clear instructions. +
- Apply skills in clear communication, responsible teamwork and time management by, for example, managing a team or project and communicating with external stakeholders. +
- Recognize the need for and demonstrate an ability to engage in continuing professional development in its broadest sense. +
+
+ {% endif %}
+ {% if show_summaries | default(false) %}
+ {% include "jinja_program.html" %}
+ {% 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) %}
+
+
+
+ {% endfor %}
+ {% else %}
+
+
+ {% endif %}
+
+ Changed fields ({{ diff_changes|length }})
+ {% if diff_changes[0].course is defined %} + {% for group in diff_changes %} +{{ group.course }}
+ | Field | Old Value | New Value |
|---|---|---|
| {{ c.field }} | {{ c.old }} | {{ c.new }} |
| Field | Old Value | New Value |
|---|---|---|
| {{ c.field }} | {{ c.old }} | {{ c.new }} |
{{ course._version_label }}
+ {% endif %}
+ | Course Code | +{{ course.course_code | course_code_for_year(course.semester, curriculum_year) }} | +Course Title | +{{ course.course_title }} | +||||
|---|---|---|---|---|---|---|---|
| Program | +{{ course.program }} | +Hours per week/ Credit Assigned | +L | +T | +P | +S | +C | +
| {{ course.lecture_hours }} | +{{ course.tutorial_hours }} | +{{ course.practical_hours }} | +{{ course.self_study }} | +{{ course.credits }} | +|||
| Semester | +{{ course.semester }} | +Type of Course | +{{ course.course_type }} | +||||
| AI Tools / Tools / Languages | +{{ course.tools_languages }} | +Desirable Knowledge | +{{ course.desirable_knowledge }} | +||||
| Prelude | +{{ course.prelude }} | +
|---|---|
| Course Objectives: | +
+
|
+
| Course Contents | +
+ {% if course.units %}
+ {% for unit in course.units %}
+
+
+ {% endfor %}
+ {% else %}
+ -
+ {% endif %}
+ {{ unit.title }} +{{ unit.content }} +{{ unit.hours }} Hours + |
+
| Laboratory | +
+
|
+
| Text Book(s): | +
+ {% if course.text_books %}
+
|
+
| Reference Book(s): | +
+
|
+
| Course Outcome | +
+
|
+
No refined courses found for Semester {{ semester }}.
+ {% endif %}
+ {% if show_thank_you | default(true) %}
+
+
+
+ Thank You
+P.E.S. University - Curriculum {{ curriculum_year }}
+{{ code }}
{% endfor %}{{ code }}
{% endfor %}{{ SEMESTER_NAMES[summary_semester|string] }} SEMESTER {{ batch_label(summary_semester, curriculum_year) }}
+ + {% if totals.count %} +| Sl. No. | +Course Code | +Course Title | +Hours per week | +Credits | +AI Tools / Tools / Languages |
+ Course Type | +|||
|---|---|---|---|---|---|---|---|---|---|
| L | +T | +P | +S | +C | +|||||
| {{ row.number }} | ++ | {{ pname }} | ++ | + | + | + | 4 | ++ | Elective Course | +
| Total | +{{ total_cell(totals.lecture, totals.lecture_credit) }} | +{{ totals.tutorial }} | +{{ totals.practical }} | +{{ totals.self_study }} | +{{ totals.credits }} | ++ | + | ||
| + {% 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 %} + | +
|---|
| ELECTIVES TO BE OPTED FOR SPECIALIZATION | +|||
|---|---|---|---|
| Sl. No. | +Specialization | +{{ "Elective-I" if summary_semester == 5 else "Elective-III" }} | +{{ "Elective-II" if summary_semester == 5 else "Elective-IV" }} | +
+
+
+
+
+
+
+ Courses
+Manage refined courses used by preview, editor, and versions.
+
+ Add Course
+ Agentic Editor
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Loading courses...
+
+ | Semester | +Code | +Course | +Credits | +Visible | ++ |
|---|
+
+
+
+
+
+
+
+
+
+
+
diff --git a/frontend/form.html b/frontend/form.html
new file mode 100644
index 0000000000000000000000000000000000000000..aed38b04847c1859187641560ab2009000829571
--- /dev/null
+++ b/frontend/form.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+ Syntagma
+An Agentic Curriculum Lifecycle Management System for PES University
+ +Syntagma is a FastAPI + static-frontend application that collects course submissions from faculty, refines them into curriculum-ready records with an LLM, renders the entire syllabus as HTML/PDF, lets an assistant agent propose and apply reviewable edits, and preserves named curriculum snapshots (versions).
+ +It is built for a real, fast-changing syllabus: PESU revamps course content nearly every academic year, so nothing about the produced document is hardcoded. Course data, elective categorization, and specialization brackets all live in the database and are rendered dynamically.
+ +Live Demo: syntagma.lonelyguy.tech (preferred) | Backup: pesucurriculum.vercel.app
+ +
+
+
+ Features
+-
+
- Course submission with auto-parsed course codes (semester, department, credits extracted automatically) +
- AI refinement that preserves all syllabus topics, only cleans and structures content +
- Full curriculum PDFs in PES University's official A4 format with letterhead +
- Agentic Editor with AI assistant (SSE streaming, 35 tools, draft review, attachments) +
- Reviewable drafts (agent never auto-applies changes) +
- Agent retry with fallback model (Fibonacci backoff on 502/503, automatic model switch) +
- Chat persistence (messages, tool calls, and results saved to database) +
- Dynamic specialization management (DB-driven tracks, not hardcoded) +
- Version snapshots with restore, revision history, and version-vs-version comparison +
- Course visibility toggle and credit-based sorting +
- Dual cache layer (Redis + in-memory, lazy invalidation) +
- Authentication via Supabase Auth +
Tech Stack
+| Component | Technology | Purpose |
|---|---|---|
| Backend framework | FastAPI 0.138 + Uvicorn | ASGI server, routing, validation |
| Language | Python 3.12 | Runtime |
| Frontend | Vanilla HTML/CSS/JS | No build step, served as static files |
| Database | Supabase (PostgreSQL) | Persistent storage for all data |
| Cache | Upstash Redis (optional) | Serverless Redis; falls back to in-memory dict |
| LLM provider | OpenRouter | Streaming + tool calling, fallback model retry |
| PDF engine | WeasyPrint | A4 curriculum PDFs from Jinja2 HTML |
| Templating | Jinja2 | Curriculum layout, course pages, diffs |
| HTTP client | httpx | Async requests to OpenRouter and external URLs |
| Spreadsheet parsing | openpyxl | Reading uploaded .xlsx files for text extraction |
| Markdown rendering | marked.js (CDN) | Agent chat message rendering in browser |
| HTML sanitization | DOMPurify (CDN) | Sanitizing agent-generated HTML |
| PDF text extraction | poppler-utils (pdftotext) | Extracting text from uploaded PDF attachments |
| Auth | Supabase Auth (JWT) | Browser-based authentication |
| Error tracking | Sentry SDK (optional) | Production error monitoring |
| Deployment | Docker on HF Spaces | Backend at port 7860 |
| Frontend deploy | Vercel | Static hosting with /api rewrite to backend |
Quick Start
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+cd backend && fastapi dev app/main.pyServer at http://127.0.0.1:8000. API under /api. Frontend served from frontend/.
source .venv/bin/activate
+pytest # 229 tests
+python -m compileall backend/app # also runs in CI
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Architecture
+ +
+flowchart TB
+ subgraph Frontend["Frontend (Vanilla HTML/CSS/JS)"]
+ Auth["/auth/ Sign In"]
+ Dashboard["/ Dashboard"]
+ Form["/form/ Course Submission"]
+ Courses["/courses/ Course Management"]
+ Preview["/preview/ PDF Preview"]
+ Editor["/live-editor/ Agentic Editor"]
+ Versions["/versions/ Version History"]
+ end
+
+ subgraph Backend["FastAPI Backend (/api)"]
+ direction TB
+ SubAPI["Submissions"]
+ CoursesAPI["Courses"]
+ PreviewAPI["Preview (8 endpoints)"]
+ AgentAPI["Agent (13 endpoints)"]
+ ChatAPI["Chat (SSE streaming)"]
+ VersionsAPI["Versions (10 endpoints)"]
+ end
+
+ subgraph Services["Services Layer"]
+ Refinement["Refinement - LLM content extraction"]
+ AgentTools["Agent Tools - 35 tools"]
+ Diffing["Diffing - protected field validation"]
+ Curriculum["Curriculum - sorting, snapshots"]
+ PreviewSvc["Preview - build_course_preview"]
+ Rendering["Rendering - Jinja2 + WeasyPrint"]
+ Cache["Cache - Redis + in-memory"]
+ end
+
+ subgraph External["External Services"]
+ LLM["OpenRouter - Primary + Fallback"]
+ Redis[("Upstash Redis")]
+ Supa[(Supabase Postgres)]
+ WeasyPrint["WeasyPrint - A4 PDF"]
+ end
+
+ Auth -->|"JWT"| Dashboard
+ Dashboard --> Form & Courses & Preview & Editor & Versions
+
+ Form -->|"POST /submissions"| SubAPI
+ SubAPI --> Refinement
+ Refinement -->|"extract content"| LLM
+ Refinement -->|"store"| Supa
+
+ Courses --> CoursesAPI
+ CoursesAPI --> Cache
+ Cache -.->|"miss"| Supa
+
+ Preview --> PreviewAPI
+ PreviewAPI --> PreviewSvc
+ PreviewSvc --> Rendering
+ Rendering --> WeasyPrint
+
+ Editor -->|"SSE"| ChatAPI
+ ChatAPI --> LLM
+ LLM -->|"tool calls"| AgentTools
+ AgentTools --> Supa
+ ChatAPI -->|"save"| Supa
+
+ VersionsAPI --> Curriculum
+ Curriculum -->|"snapshot"| Supa
+
+ Editor -->|"review/apply"| AgentAPI
+ AgentAPI --> Diffing
+ Diffing -->|"validate"| Supa
+
+ Cache -.-> Redis
+
+
+ Layer Responsibilities
+| Layer | Location | Responsibility |
|---|---|---|
| Static frontend | frontend/ | Course entry, course management, PDF preview, agentic editor, version history |
| API backend | backend/app/ | FastAPI routes, validation, refinement, previews, drafts, chat, snapshots |
| Services | backend/app/services/ | Business logic, LLM integration, caching, diffing, tool dispatch |
| Persistence | Supabase Postgres | Raw submissions, refined courses, agent drafts, chat history, attachments, curriculum versions |
| Cache | Redis + in-memory | Course lists, version lists, PDFs, with lazy invalidation |
| Rendering | Jinja2 + WeasyPrint | Curriculum summary pages, course detail pages, PDF exports |
| Model provider | OpenRouter | Submission refinement and live-editor chat with tool calls + fallback model retry |
| Auth | Supabase Auth (JWT) | Browser-based authentication with token verification |
| Monitoring | Sentry SDK | Optional production error tracking |
Backend Project Structure
+| Path | Responsibility |
|---|---|
| main.py | FastAPI app, CORS, Supabase/.env loading, mounts /api routers and the static frontend |
| api.py | Aggregates all route routers under a single /api router |
| supabase.py | Supabase client + first_row() helper |
| cache.py | Dual cache (Redis + in-memory), lazy invalidation, prefix-based deletion |
| models/submission.py | CourseSubmission (request contract) and parse_course_code() |
| services/deterministic.py | compute_hours, compute_program, compute_course_type from credit category |
| services/refinement.py | The LLM refinement pipeline (refine) |
| services/curriculum.py | Sorting, ordering, version snapshots, draft records, field updates |
| services/diffing.py | JSON diff, protected-field validation, patch apply/merge |
| services/preview.py | build_course_preview, build_specialization_context |
| services/rendering.py | Jinja2 environment, filters, SEMESTER_NAMES global |
| services/agent_tools.py | Agent tool definitions + TOOLS registry (35 tools) + call_tool |
| services/openrouter.py | call() (one-shot), stream_chat() (tool-calling loop), fallback model retry |
| services/schema.py | REQUIRED_TABLES and schema_status() |
| services/errors.py | database_http_exception() |
| services/attachments.py | Text extraction from PDF/DOCX/XLSX/TXT |
| services/books.py | parse_books() textbook parser |
| services/elective_categorization.py | AI-powered elective-to-track matching |
| routes/health.py | GET /api/health/schema |
| routes/submissions.py | POST /api/submissions, POST /api/submissions/{id}/refine |
| routes/preview.py | Course/HTML/PDF preview endpoints (8 endpoints) |
| routes/refined.py | GET/PATCH a single refined course |
| routes/courses.py | List + toggle visibility + soft-delete refined courses |
| routes/agent.py | Draft + document-draft + tool endpoints (13 endpoints) |
| routes/chat.py | Chat sessions, SSE streaming, attachments, system prompt |
| routes/versions.py | Version CRUD, restore, previews, diffs (10 endpoints) |
| routes/auth.py | Token verification, logout |
| templates/jinja_sample.html | Single course + full document renderer + title page |
| templates/jinja_program.html | Program-level title page (large seal) + PEOs/POs |
| templates/jinja_1_to_8.html | Semester summary tables (1-4, 7-8) |
| templates/jinja_sem_5_6.html | Semester 5/6 electives + specialization tables |
| templates/jinja_diff.html | Structured diff renderer for drafts |
Frontend Project Structure
+| Path | Purpose |
|---|---|
| index.html | Dashboard hub linking to all surfaces |
| form/ | Raw course submission form with course code parsing |
| courses/ | Refined course list with filtering, visibility toggle, soft delete |
| preview/ | Overall or per-semester PDF preview/download |
| live-editor/ | Agentic Editor: course preview, chat assistant, JSON editor, draft review, version restore |
| versions/ | Snapshot list, preview, comparison, editor handoff |
| auth/ | Sign in (Supabase Auth) |
| shared/ | auth-guard.js, supabase-client.js, shared.css, dialog.js |
+
+
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+ 
+ 
+ 
+
+ How It Works
+Syntagma has six surfaces. Each serves a purpose in the curriculum lifecycle.
+ +Authentication
+
+ Supabase Auth with email/password. JWT verified on every API call. The shared/auth-guard.js script redirects unauthenticated users to /auth/.
Dashboard
+
+ Quick links to all surfaces: Submission Form, Courses, Preview, Live Editor, Versions, and Documentation.
+ +Submission Form
+
+ Faculty enter raw course data. Course codes are auto-parsed: semester, department, credits, and course type extracted from the code. Background refinement kicks in immediately after submission. Alternatively, course details can be sent as attachments in the agent chat, where the agent creates a refined course directly using create_refined_course.
Courses
+
+
+
+ Lists all refined courses. Filter by semester or department. Toggle visibility (hidden courses are excluded from previews and PDFs). Delete with confirmation modal.
+ +Preview
+
+
+
+ Three view modes: single course, full document, or per-semester. PDFs generated via WeasyPrint in PES University's A4 format with letterhead.
+ +Agentic Editor
+
+
+
+ Two-column workspace. Left: preview iframe (single course or full document). Right: tabbed panel.
+| Tab | What it does |
|---|---|
| Agent | AI assistant via SSE streaming. 35 tools. Creates reviewable drafts, never auto-applies. Thread management with rename/delete. File attachments supported. |
| Fields | Raw JSON editor. "Propose Changes" creates a reviewable draft. "Save" directly updates (non-protected fields only). |
| Review | Loads pending drafts (new courses, single-course, multi-course). Shows diff. Apply or reject. |
Versions
+
+
+
+
+ Named snapshots of the entire curriculum. "Current" at top of sidebar represents live state. Preview any snapshot, compare two versions, or restore a previous state. Restore archives absent courses and resets applied drafts.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Backend Internals
+ +Submission Pipeline
+| Step | What happens |
|---|---|
| 1 | POST /api/submissions validates payload against CourseSubmission |
| 2 | parse_course_code() derives offering_department, target_department, semester, credit_category |
| 3 | Inserts into submissions, queues background refinement |
| 4 | refine(submission_id) builds deterministic fields, calls OpenRouter, upserts refined_submissions |
| 5 | Course visible in /api/courses, previews, and editor |
Alternative path: course details sent as chat attachments can be used by the agent to create a refined course directly via create_refined_course, bypassing the submission/refinement pipeline.
Course Code Encoding
+UE + YY (year) + DEPT (2-letter) + NUMBER (3-digit) + SUFFIX.
| Digit | Meaning |
|---|---|
| Tens | Credits (0/2/4/5) |
| Hundreds | Semester group |
| Suffix A/B | Odd/even semester parity |
parse_course_code() in models/submission.py is the single source of truth.
Deterministic Fields
+Computed from credit_category by services/deterministic.py. Protected from casual edits.
| 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 |
Protected fields (diffing.py): program, lecture_hours, tutorial_hours, practical_hours, self_study, credits, course_type. Drafts that change them are blocked.
Preview & PDF Generation
+build_course_preview(row) converts a refined_submissions row into a flat dict for templates. services/rendering.py builds the Jinja2 environment.
| Template | Renders |
|---|---|
jinja_program.html | Title page (PES seal, program name, year) and PEOs/POs |
jinja_sample.html | Individual course pages and summary tables |
jinja_1_to_8.html | Semester summary tables (1-4, 7-8) |
jinja_sem_5_6.html | Electives and specialization tables (5/6) |
jinja_diff.html | Structured diffs for agent drafts |
WeasyPrint converts rendered HTML to PDF. PDFs cached 60s. Course lists and version lists cached 180s.
+ +Specialization System
+Fully data-driven. No hardcoded specialization brackets.
+| Table | Schema |
|---|---|
specialization_definitions | One row per track: id, semester, letter, name, key, academic_year |
course_specialization_assignments | One row per (course, track): id, refined_id, specialization_id |
refined_submissions.is_elective | Boolean flag |
build_specialization_context() loads tracks and assignments. Template excludes electives from regular tables, splits by code suffix (AA/BA -> group A), renders specialization assignment tables.
Agent tools: define_specialization, list_specializations, assign_elective_to_tracks, remove_elective_from_tracks, categorize_elective.
Agent System
+Tool-calling LLM loop via openrouter.stream_chat. System prompt in chat.py:chat_system_prompt.
| Component | Purpose |
|---|---|
| Curriculum structure context | Semester ranges, course code encoding, credit categories |
| Draft vs. direct creation guidelines | When to draft vs. create directly |
| Desirable knowledge guidance | How to handle prerequisite knowledge fields |
| Agent acknowledgement instruction | Brief text before tool calls |
update_agent_draft tool mention | Modifying existing drafts |
Agent Tools (35 total)
+| Tool | Category | Description |
|---|---|---|
get_current_course_json | Read | Full template-ready course JSON |
get_course_codes | Read | Lightweight IDs (refined_id, code, title, semester) |
get_course_syllabus | Read | Units, objectives, course_outcomes |
get_course_textbooks | Read | text_books, reference_books |
get_course_deterministic | Read | Protected fields (read-only context) |
get_course_lab | Read | Lab experiments, tools/languages |
get_course_fields | Read | Arbitrary field subset for one course |
batch_read_courses | Read | Read specific fields from multiple courses in one call |
get_curriculum_json | Read | Full curriculum, optionally by semester |
list_courses | Read | Course IDs/titles, optionally by semester |
get_curriculum_stats | Read | Aggregate statistics (total courses, credits per semester, course type distribution) |
diff_course_json | Read | Compare two course JSONs |
get_course_draft | Read | Read a staged course draft |
get_document_draft | Read | Read a staged document draft |
get_version | Read | Load a curriculum version snapshot with its course list |
diff_versions | Read | Compare two version snapshots (added/removed/changed courses) |
get_course_assignments | Read | Which specialization tracks a course belongs to |
list_specializations | Read | List track definitions |
get_attachment_text | Read | Read uploaded chat attachments |
fetch_url | Read | Fetch external URL content |
web_search | Read | Search the web for external context |
create_course_draft | Write | Propose changes for a single course (reviewable draft) |
update_agent_draft | Write | Merge fields into an existing draft (avoids duplicates) |
create_document_draft | Write | Propose changes for multiple courses (reviewable draft) |
assign_elective_to_tracks | Write | Categorize an elective into specialization tracks |
remove_elective_from_tracks | Write | Remove a course from specialization tracks |
define_specialization | Write | Create a new specialization track |
categorize_elective | Write | AI-powered elective categorization into existing tracks |
update_deterministic_fields | Write | Change protected fields; produces a blocked draft requiring explicit user approval |
create_refined_course | Write | Create new courses directly (for brand-new courses only) |
create_spreadsheet | Generate | Generate CSV or Excel (.xlsx) files from structured row data |
create_report | Generate | Generate markdown or PDF reports |
create_curriculum_version | Generate | Snapshot the current curriculum state |
signal_done | Control | Signal task completion with a summary |
SSE Event Types
+Streamed from POST /chat/sessions/{id}/messages:
| Event | Description |
|---|---|
status | Status updates (model name, tool execution) |
token | Streamed text tokens from the LLM |
tool_call | Agent invoking a tool (name + arguments) |
tool_result | Tool execution result |
draft | A course draft was created |
document_draft | A document draft was created |
refined_course | A new course was created directly |
context_usage | Token usage statistics |
error | Error occurred |
done | Stream complete |
Chat Persistence
+All messages (user, assistant, tool_call, tool_result) saved to chat_messages with role and metadata. Tool calls include function name and arguments; tool results include output. Conversation history persists across page refreshes.
Agent Output Validation
+| Validation | Behavior |
|---|---|
desirable_knowledge | Placeholder values (e.g., "None specified") stripped by _create_refined_course |
| Draft-status courses | _create_course_draft rejects drafts, directs agent to create_refined_course |
Versioning
+create_version_snapshot copies every active refined_submissions into finalized_submissions pinned to a curriculum_versions row. restore overwrites current refined data, archives absent courses, writes revision history.
Caching
+Dual cache layer (services/cache.py):
| Backend | Config | Behavior |
|---|---|---|
| Redis (Upstash, optional) | REDIS_URL | Survives server restarts |
| In-memory dict | Fallback | Survives within a process |
| Prefix | TTL | Purpose |
|---|---|---|
courses_list | 180s | Course list for /api/courses |
course_pdf: | 60s | Individual course PDF bytes |
version_list | 180s | Version list for /api/versions |
Invalidation: lazy (delete-on-write). Prewarm on startup. Debug: set is_cache_disabled = True in cache.py.
Error Handling & Retry
+OpenRouter client (services/openrouter.py):
| Parameter | Value |
|---|---|
| Retryable statuses | 502, 503 (server errors) |
| Retryable exceptions | httpx.TimeoutException, httpx.TransportError |
| NOT retried | 429 (rate limit) - shows error and stops immediately |
| Backoff | Fibonacci sequence [1, 1, 2, 3, 5, 8, 13] seconds with +/-25% jitter |
| Max retries | 3 per request |
| Retry-After header | Respected when present |
Fallback model:
+| Parameter | Behavior |
|---|---|
OPENROUTER_FALLBACK_MODEL | Set env var to enable (e.g. google/gemma-3-27b-it:free) |
| Trigger | After 3 failed retries on the primary model |
| Scope | Commits to fallback for the rest of the chat thread |
| Notification | Announced via SSE status events so the UI can inform the user |
| Persistence | Once committed, active_model persists as the fallback for all subsequent calls |
429 (rate limit): No retry, no fallback. Error shown in chat and status bar. User must wait and retry manually.
+Chat streaming errors: Surfaced as SSE error events. UI creates error bubble even when no tokens received. Done handler reloads messages from database.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ API Reference
+All paths are prefixed with /api at runtime.
Health
+| Endpoint | Method | Purpose |
|---|---|---|
/api/health/schema | GET | Verify required Supabase tables exist. Returns 503 if tables are missing. |
Submissions
+| Endpoint | Method | Purpose |
|---|---|---|
/api/submissions | POST | Store a raw submission, queue background refinement. Body: CourseSubmission. |
/api/submissions/{id}/refine | POST | Manually trigger refinement for an existing submission. |
Refined Courses
+| Endpoint | Method | Purpose |
|---|---|---|
/api/refined/{refined_id} | GET | Read template-ready course fields. |
/api/refined/{refined_id} | PATCH | Update editable refined fields. Promotes draft-status courses to refined. Body: { fields: dict }. |
Course Management
+| Endpoint | Method | Purpose |
|---|---|---|
/api/courses | GET | List active refined courses (cached 180s). |
/api/courses/{refined_id}/visible | PATCH | Toggle course visibility. Body: { visible: bool }. |
/api/courses/{refined_id} | DELETE | Soft-delete (archive) a course. |
Preview & PDF
+| Endpoint | Method | Purpose |
|---|---|---|
/api/preview/course/{refined_id} | GET | Render one course as HTML. |
/api/preview/course/{refined_id}/pdf | GET | Generate PDF for one course. ?download=true for attachment. |
/api/preview/html | GET | Render full curriculum as HTML. |
/api/preview/pdf | GET | Generate full curriculum PDF. ?download=true for attachment. |
/api/preview/semester/{sem}/pdf | GET | Generate one semester as PDF. |
/api/preview/semester/{sem}/courses | GET | List course IDs for a semester. |
/api/preview/pending-courses | GET | List draft-status (pending) courses. |
/api/preview/courses | GET | List all visible refined course IDs. |
Agent Drafts
+| Endpoint | Method | Purpose |
|---|---|---|
/api/agent/drafts | GET | List 100 most recent agent drafts. |
/api/agent/drafts | POST | Create a single-course draft. Body: { refined_id, fields, reason? }. |
/api/agent/drafts/{draft_id} | GET | Fetch a draft with base/proposed JSON and diff summary. |
/api/agent/drafts/{draft_id}/apply | POST | Apply a proposed draft. Rejects blocked drafts or protected-field changes. |
/api/agent/drafts/{draft_id}/preview | GET | Render draft as HTML. ?diff=true for diff view. |
Document Drafts (multi-course)
+| Endpoint | Method | Purpose |
|---|---|---|
/api/agent/document-drafts | GET | List 100 most recent document drafts. |
/api/agent/document-drafts | POST | Create a multi-course draft. Body: { courses: [{ refined_id, fields }], reason? }. |
/api/agent/document-drafts/{id} | GET | Fetch document draft with all linked course drafts. |
/api/agent/document-drafts/{id}/apply | POST | Apply all proposed sub-drafts. |
/api/agent/document-drafts/{id}/preview | GET | Render all proposed courses. ?diff=true for diff view. |
Agent Tools & Diff
+| Endpoint | Method | Purpose |
|---|---|---|
/api/agent/tools | GET | List all agent tool schemas (OpenAI function-calling format). |
/api/agent/tools/{tool_name} | POST | Execute a tool directly. Body: { arguments: dict }. |
/api/agent/context-length | GET | Return current model's context window size. |
/api/agent/diff | POST | Compute structured diff between two course JSONs. |
Chat
+| Endpoint | Method | Purpose |
|---|---|---|
/api/chat/sessions | GET | List active sessions. ?refined_id= or ?document_draft_id= to filter. |
/api/chat/sessions | POST | Create a session. Body: { refined_id?, document_draft_id?, title? }. |
/api/chat/sessions/{id} | PATCH | Rename a session. Body: { title }. |
/api/chat/sessions/{id} | DELETE | Soft-archive a session and its messages. |
/api/chat/sessions/{id}/messages | GET | Fetch all messages in a session. |
/api/chat/sessions/{id}/messages | POST | Send a message and stream response via SSE. Events: status, token, tool_call, tool_result, draft, document_draft, refined_course, context_usage, error, done. |
/api/chat/sessions/{id}/attachments | POST | Upload files (multipart/form-data). 10MB/file, 25MB total. |
/api/chat/sessions/{id}/attachments/{att_id}/download | GET | Download an attachment. |
/api/chat/sessions/{id}/attachments/{att_id}/preview | GET | Preview an attachment inline. |
Versions
+| Endpoint | Method | Purpose |
|---|---|---|
/api/versions | GET | List all curriculum snapshots. Includes course_count and has_changes. |
/api/versions | POST | Create a snapshot. Returns 409 if no changes since last version. Body: { name, program?, academic_year?, status? }. |
/api/versions/{version_id} | GET | Fetch version with its course list. |
/api/versions/{version_id} | PATCH | Update version metadata. Body: { name?, academic_year?, status? }. |
/api/versions/{version_id} | DELETE | Delete a version and its finalized_submissions. |
/api/versions/{version_id}/restore | POST | Restore a snapshot. Archives absent courses. Resets applied drafts. |
/api/versions/{version_id}/courses/{refined_id} | GET | Fetch a single course snapshot from a version. |
/api/versions/{version_id}/courses/{refined_id}/preview | GET | Render a version course as HTML. |
/api/versions/{version_id}/preview | GET | Render all version courses. ?diff=true for diff vs current. |
/api/versions/{id1}/diff/{id2} | GET | Render side-by-side diff between two versions. |
Auth
+| Endpoint | Method | Purpose |
|---|---|---|
/api/auth/check | GET | Verify the bearer token is valid. Returns user info or 401. |
/api/auth/logout | POST | Sign out the current user. |
Query Parameters
+| Parameter | Applies to | Description |
|---|---|---|
curriculum_year | All preview/PDF endpoints | Pin the batch year (e.g. 2025-2026). Falls back to CURRICULUM_YEAR env var. |
download | PDF endpoints | Set true to trigger Content-Disposition attachment. |
diff | Draft/version preview | Set true to render diff view instead of proposed content. |
Total: 49 endpoints across 9 route files.
+
+
+
+
+
+
+
+
+
+ Database Schema
+Run docs/schema.sql in the Supabase SQL editor. Required tables:
submissions, refined_submissions, curriculum_versions, finalized_submissions, agent_drafts, agent_document_drafts, course_revision_history, chat_sessions, chat_messages, chat_attachments, specialization_definitions, course_specialization_assignments.
Course Status Lifecycle
+submissions.status: pending -> refined
+refined_submissions: draft -> refined -> archived
+agent_drafts: proposed -> applied
+ blocked -> proposed (on user edit)
+chat_sessions: active -> archivedKey Columns on refined_submissions
+course_code, course_title, semester, credit_category, program, lecture_hours, tutorial_hours, practical_hours, self_study, credits, course_type, is_elective, visible, units (jsonb), objectives/text_books/... (arrays), status.
visible (default true) controls whether a course renders in preview/PDF output. Toggle it from the course management page. Hidden courses stay in the database and remain editable but are excluded from every rendered document.
Verify with GET /api/health/schema.
Table Relationships
+refined_submissions (1) ----< (N) agent_drafts
+refined_submissions (1) ----< (N) course_revision_history
+curriculum_versions (1) ----< (N) finalized_submissions
+agent_document_drafts (1) ----< (N) agent_drafts
+chat_sessions (1) ----< (N) chat_messages
+chat_sessions (1) ----< (N) chat_attachments
+specialization_definitions (1) ----< (N) course_specialization_assignments
+refined_submissions (1) ----< (N) course_specialization_assignmentsSpecialization Tables
+| Table | Schema |
|---|---|
specialization_definitions | One row per track: id, semester, letter (A/B/C...), name, key (SCC/MIDS/CSCS), academic_year |
course_specialization_assignments | One row per (course, track) membership: id, refined_id, specialization_id |
refined_submissions.is_elective | Boolean flag marking a course as an elective |
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Environment Variables
+ +Required backend (/api server, loaded from repo-root .env)
+| Variable |
|---|
SUPABASE_URL |
SUPABASE_KEY |
OPENROUTER_URL |
OPENROUTER_API_KEY |
OPENROUTER_MODEL |
Optional
+| Variable | Description |
|---|---|
CURRICULUM_YEAR | The active batch label (e.g. 2025-2026) |
OPENROUTER_FALLBACK_MODEL | Backup model used when the primary model fails after retries (e.g. google/gemma-3-27b-it:free) |
REDIS_URL | Upstash Redis URL for persistent caching (falls back to in-memory) |
SENTRY_DSN, SENTRY_ENVIRONMENT, SENTRY_RELEASE | Error tracking configuration |
The frontend uses the public Supabase anon key directly in shared/supabase-client.js.
+
+
+
+
+
+
+
+
+
+
+
+
+ Deployment
+ +Backend (HF Spaces)
+Docker image runs uvicorn app.main:app --host 0.0.0.0 --port 7860 (HF Space).
.github/workflows/sync-to-hub.yml syncs main to the HF Space.
Required HF Space secrets:
+| Secret | Description |
|---|---|
SUPABASE_URL, SUPABASE_KEY | Database connection |
OPENROUTER_URL, OPENROUTER_API_KEY, OPENROUTER_MODEL | LLM provider |
OPENROUTER_FALLBACK_MODEL | Recommended fallback model |
REDIS_URL | Optional persistent caching |
SENTRY_DSN, SENTRY_ENVIRONMENT, SENTRY_RELEASE | Optional error tracking |
Frontend (Vercel)
+Static hosting with frontend/vercel.json rewriting /api/* to the backend.
Required Vercel environment variables:
+| Variable | Description |
|---|---|
NEXT_PUBLIC_SUPABASE_URL | Public Supabase URL |
NEXT_PUBLIC_SUPABASE_ANON_KEY | Public Supabase anon key |
CI (.github/workflows/ci.yml)
+Runs on push/PR: checkout, Python 3.12, pip install (cached), apt-get install poppler-utils, pytest, python -m compileall backend/app.
Local Development
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+cd backend && fastapi dev app/main.pyServer at http://127.0.0.1:8000. API under /api. Frontend served from frontend/.
source .venv/bin/activate
+pytest # all tests
+python -m compileall backend/app # also runs in CICourse Details
+ + + + + + + + + + + Override if the code does not match your intended category. + + + + Topics, units, or rough syllabus. +References
+ + + + + + + + + +Syntagma
+ + + +Loading...
+ Loading preview...
';
+ previewOverlay.hidden = false;
+ const mime = (file.type || "").toLowerCase();
+ const name = (file.name || "").toLowerCase();
+ try {
+ const url = `/api/chat/sessions/${activeSessionId}/attachments/${file.id}/preview`;
+ const response = await fetch(url);
+ if (!response.ok) throw new Error("Preview failed");
+ if (mime === "application/pdf" || name.endsWith(".pdf")) {
+ const blob = await response.blob();
+ const blobUrl = URL.createObjectURL(blob);
+ previewBody.innerHTML = ``;
+ } else if (mime.includes("markdown") || name.endsWith(".md")) {
+ const text = await response.text();
+ const html = typeof DOMPurify !== "undefined" ? DOMPurify.sanitize(marked.parse(preprocessUrls(text))) : marked.parse(preprocessUrls(text));
+ previewBody.innerHTML = `${html}
`;
+ } else if (mime.includes("spreadsheet") || mime.includes("excel") || name.endsWith(".xlsx") || name.endsWith(".csv")) {
+ if (name.endsWith(".xlsx")) {
+ const html = await response.text();
+ previewBody.innerHTML = html;
+ } else {
+ const text = await response.text();
+ const table = csvToTable(text, true);
+ previewBody.innerHTML = table;
+ }
+ } else if (mime.includes("word") || name.endsWith(".doc") || name.endsWith(".docx")) {
+ const text = await response.text();
+ previewBody.innerHTML = `${escapeHtml(text)}`;
+ } else {
+ const text = await response.text();
+ previewBody.innerHTML = `${escapeHtml(text)}`;
+ }
+ } catch (error) {
+ previewBody.innerHTML = `Could not load preview.
`;
+ }
+}
+
+function escapeHtml(text) {
+ const div = document.createElement("div");
+ div.textContent = text;
+ return div.innerHTML;
+}
+
+function csvToTable(text, isCsv) {
+ const lines = text.split("\n").filter((l) => l.trim());
+ if (!lines.length) return `${escapeHtml(text)}`;
+ const rows = lines.map((line) => {
+ const cells = [];
+ let current = "";
+ let inQuotes = false;
+ for (let i = 0; i < line.length; i++) {
+ const ch = line[i];
+ if (inQuotes) {
+ if (ch === '"' && line[i + 1] === '"') { current += '"'; i++; }
+ else if (ch === '"') inQuotes = false;
+ else current += ch;
+ } else {
+ if (ch === '"') inQuotes = true;
+ else if (ch === "\t" || (isCsv && ch === ",")) { cells.push(current); current = ""; }
+ else current += ch;
+ }
+ }
+ cells.push(current);
+ return cells;
+ });
+ const header = rows.shift();
+ if (!header) return `${escapeHtml(text)}`;
+ let html = '| ${escapeHtml(h)} | `; }); + html += "
|---|
| ${escapeHtml(cell)} | `; }); + html += "
+
+
+
+
+
diff --git a/frontend/preview/preview.css b/frontend/preview/preview.css
new file mode 100644
index 0000000000000000000000000000000000000000..9b2db75b38eb9813297a87d244e021b7e3cff37a
--- /dev/null
+++ b/frontend/preview/preview.css
@@ -0,0 +1,103 @@
+@import "../shared.css";
+
+* {
+ box-sizing: border-box;
+}
+
+body {
+ margin: 0;
+ min-height: 100dvh;
+ padding: 2rem;
+ background: var(--page-bg);
+ color: var(--text);
+}
+
+.toolbar {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ flex-wrap: wrap;
+ padding: 1rem 1.5rem;
+ background: var(--surface);
+ border: 1px solid var(--border);
+ border-radius: 16px;
+ box-shadow: var(--shadow-md);
+ margin-bottom: 1.25rem;
+}
+
+select {
+ min-width: 150px;
+}
+
+input {
+ width: 120px;
+ padding: 0 10px;
+}
+
+.year-control {
+ display: inline-flex;
+ align-items: center;
+ gap: 8px;
+ color: var(--muted-foreground);
+ font-size: 14px;
+}
+
+a {
+ display: inline-flex;
+ align-items: center;
+ padding: 0 12px;
+ text-decoration: none;
+}
+
+#status {
+ margin-left: auto;
+}
+
+.loading {
+ position: absolute;
+ inset: 0;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ gap: 12px;
+ background: var(--background);
+ z-index: 5;
+ color: var(--muted-foreground);
+ font-size: 14px;
+ border-radius: 16px;
+}
+
+.loading[hidden] {
+ display: none;
+}
+
+.spinner {
+ width: 24px;
+ height: 24px;
+ border: 2.5px solid var(--border);
+ border-top-color: var(--primary);
+ border-radius: 50%;
+ animation: spin 0.6s linear infinite;
+}
+
+@keyframes spin { to { transform: rotate(360deg); } }
+
+iframe {
+ display: block;
+ width: 100%;
+ height: calc(100dvh - 140px);
+ border: 0;
+ border-radius: 16px;
+ background: var(--surface);
+ box-shadow: var(--shadow-md);
+}
+
+iframe[hidden] {
+ display: none;
+}
+
+.viewer-wrap {
+ position: relative;
+ min-height: calc(100dvh - 140px);
+}
diff --git a/frontend/preview/preview.js b/frontend/preview/preview.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef9a1ce9a6737d1259aeafd1623c0d686643635d
--- /dev/null
+++ b/frontend/preview/preview.js
@@ -0,0 +1,153 @@
+const params = new URLSearchParams(location.search);
+const requestedSemester = params.get("sem");
+const storedYear = localStorage.getItem("curriculumYear") || "";
+const requestedYear = params.get("curriculum_year") || params.get("year") || storedYear;
+const semester = document.getElementById("semester");
+const course = document.getElementById("course");
+const curriculumYear = document.getElementById("curriculum-year");
+const viewer = document.getElementById("viewer");
+const openLink = document.getElementById("open");
+const downloadLink = document.getElementById("download");
+const statusText = document.getElementById("status");
+const loading = document.getElementById("loading");
+curriculumYear.value = requestedYear;
+if (requestedYear) localStorage.setItem("curriculumYear", requestedYear);
+
+function clearPreview(message) {
+ viewer.removeAttribute("src");
+ openLink.removeAttribute("href");
+ downloadLink.removeAttribute("href");
+ statusText.textContent = message;
+ if (loading) loading.hidden = true;
+}
+
+function yearValue() {
+ return curriculumYear.value.trim();
+}
+
+function saveYear() {
+ if (yearValue()) localStorage.setItem("curriculumYear", yearValue());
+}
+
+function pdfUrl(sem, download = false) {
+ const path = sem === "all" ? "/api/preview/pdf" : `/api/preview/semester/${sem}/pdf`;
+ const query = new URLSearchParams({ curriculum_year: yearValue() });
+ if (download) query.set("download", "true");
+ return `${path}?${query}`;
+}
+
+function coursePdfUrl(refinedId, download = false) {
+ const query = new URLSearchParams({ curriculum_year: yearValue() });
+ if (download) query.set("download", "true");
+ return `/api/preview/course/${refinedId}/pdf?${query}`;
+}
+
+async function courseIds(sem) {
+ const url = sem === "all" ? "/api/preview/courses" : `/api/preview/semester/${sem}/courses`;
+ const response = await fetch(url);
+ if (!response.ok) return [];
+ const body = await response.json();
+ return body.course_ids || [];
+}
+
+async function fetchCourses(sem) {
+ if (sem === "all") return [];
+ const url = `/api/preview/semester/${sem}/courses?curriculum_year=${encodeURIComponent(yearValue())}`;
+ const response = await fetch(url);
+ if (!response.ok) return [];
+ const body = await response.json();
+ return body.courses || [];
+}
+
+async function firstAvailableSemester() {
+ if ((await courseIds("all")).length) return "all";
+ for (let sem = 1; sem <= 8; sem += 1) {
+ if ((await courseIds(sem)).length) return String(sem);
+ }
+ return "all";
+}
+
+function loadIntoViewer(url, label) {
+ if (loading) loading.hidden = false;
+ viewer.hidden = true;
+
+ const onLoad = () => {
+ if (loading) loading.hidden = true;
+ viewer.hidden = false;
+ viewer.removeEventListener("load", onLoad);
+ };
+ viewer.addEventListener("load", onLoad);
+
+ viewer.src = url;
+ openLink.href = url;
+ openLink.target = "_blank";
+ downloadLink.href = url.includes("?") ? url + "&download=true" : url + "?download=true";
+ statusText.textContent = label;
+}
+
+async function loadSemester(sem) {
+ semester.value = sem;
+ statusText.textContent = "Loading...";
+
+ if (!/^\d{4}-\d{4}$/.test(yearValue())) {
+ clearPreview("Set academic year on the dashboard to preview.");
+ course.hidden = true;
+ return;
+ }
+
+ if (!(await courseIds(sem)).length) {
+ clearPreview(sem === "all" ? "No refined courses found." : `No refined courses found for Semester ${sem}.`);
+ course.hidden = true;
+ return;
+ }
+
+ if (sem === "all") {
+ course.hidden = true;
+ course.innerHTML = "";
+ loadIntoViewer(pdfUrl(sem), "Overall");
+ return;
+ }
+
+ const courses = await fetchCourses(sem);
+ course.innerHTML = "";
+ const placeholder = document.createElement("option");
+ placeholder.value = "";
+ placeholder.textContent = `All Semester ${sem} courses`;
+ course.appendChild(placeholder);
+ for (const c of courses) {
+ const opt = document.createElement("option");
+ opt.value = c.id;
+ opt.textContent = `${c.course_code} - ${c.course_title}`;
+ opt.dataset.code = c.course_code;
+ course.appendChild(opt);
+ }
+ course.value = "";
+ course.hidden = false;
+
+ loadIntoViewer(pdfUrl(sem), `Semester ${sem}`);
+}
+
+function loadSelectedCourse() {
+ const selectedId = course.value;
+ if (!selectedId) {
+ loadIntoViewer(pdfUrl(semester.value), `Semester ${semester.value}`);
+ return;
+ }
+ const opt = course.options[course.selectedIndex];
+ loadIntoViewer(coursePdfUrl(selectedId), opt.dataset.code);
+}
+
+semester.addEventListener("change", () => {
+ loadSemester(semester.value);
+});
+
+course.addEventListener("change", loadSelectedCourse);
+
+curriculumYear.addEventListener("change", () => {
+ saveYear();
+ loadSemester(semester.value);
+});
+
+(requestedSemester ? Promise.resolve(requestedSemester) : firstAvailableSemester()).then(loadSemester).catch(() => {
+ statusText.textContent = "Backend unavailable.";
+});
diff --git a/frontend/shared.css b/frontend/shared.css
new file mode 100644
index 0000000000000000000000000000000000000000..2a5bf16d220942de0f87e2aaea4e11efe5d18fe2
--- /dev/null
+++ b/frontend/shared.css
@@ -0,0 +1,257 @@
+@import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&display=swap');
+
+:root {
+ --radius: 6px;
+ --radius-sm: 4px;
+
+ --background: #ffffff;
+ --foreground: #0a0a0a;
+ --card: #ffffff;
+ --card-foreground: #0a0a0a;
+
+ --primary: #00377b;
+ --primary-foreground: #ffffff;
+ --secondary: #f4f4f5;
+ --secondary-foreground: #18181b;
+ --muted: #f4f4f5;
+ --muted-foreground: #71717a;
+ --accent: #f4f4f5;
+ --accent-foreground: #18181b;
+
+ --destructive: #dc2626;
+ --destructive-foreground: #ffffff;
+ --success: #16a34a;
+ --success-foreground: #ffffff;
+
+ --border: #e4e4e7;
+ --input: #e4e4e7;
+ --ring: #00377b;
+
+ --page-bg: #f4f4f5;
+ --surface: #ffffff;
+ --text: #0a0a0a;
+ --muted-text: #71717a;
+ --border-strong: #d4d4d8;
+
+ --pesu-blue: #00377b;
+ --pesu-orange: #ff6c00;
+ --error: #dc2626;
+ --error-bg: #fef2f2;
+ --success-bg: #f0fdf4;
+
+ --shadow-sm: 0 1px 3px rgba(18, 32, 67, 0.10), 0 1px 2px rgba(18, 32, 67, 0.08);
+ --shadow-md: 0 4px 16px -2px rgba(18, 32, 67, 0.18), 0 2px 6px rgba(18, 32, 67, 0.10);
+}
+
+*,
+*::before,
+*::after {
+ box-sizing: border-box;
+}
+
+body {
+ margin: 0;
+ min-height: 100dvh;
+ background: var(--page-bg);
+ color: var(--text);
+ font-family: 'Outfit', system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+ font-size: 14px;
+ line-height: 1.5;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+select,
+input,
+textarea,
+button,
+a.button-link {
+ min-width: 0;
+ border-radius: var(--radius);
+ font: inherit;
+ font-family: inherit;
+}
+
+select,
+input,
+textarea {
+ border: 1px solid var(--input);
+ background-color: var(--background);
+ color: var(--foreground);
+ transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+select,
+input,
+button,
+a.button-link {
+ min-height: 36px;
+}
+
+select {
+ appearance: none;
+ -webkit-appearance: none;
+ -moz-appearance: none;
+ min-width: 160px;
+ padding: 0 36px 0 12px;
+ background-color: var(--background);
+ background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath d='M3 4.5L6 7.5L9 4.5' fill='none' stroke='%2371717a' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
+ background-repeat: no-repeat;
+ background-position: right 12px center;
+ background-size: 12px;
+ cursor: pointer;
+ border-radius: 10px;
+ font-weight: 500;
+ transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+select:hover {
+ border-color: var(--border-strong);
+}
+
+input,
+textarea {
+ padding: 8px 12px;
+}
+
+button,
+a.button-link {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ gap: 6px;
+ border: 1px solid var(--border);
+ background: var(--background);
+ color: var(--foreground);
+ padding: 0 16px;
+ text-decoration: none;
+ cursor: pointer;
+ font-weight: 500;
+ transition: background 0.15s, color 0.15s, border-color 0.15s;
+}
+
+button:hover,
+a.button-link:hover {
+ border-color: var(--pesu-orange);
+}
+
+button.primary,
+a.button-link.primary {
+ border-color: var(--primary);
+ background: var(--primary);
+ color: var(--primary-foreground);
+}
+
+button.primary:hover,
+a.button-link.primary:hover {
+ border-color: color-mix(in srgb, var(--primary) 70%, white);
+}
+
+button.danger {
+ border-color: var(--destructive);
+ background: var(--destructive);
+ color: var(--destructive-foreground);
+}
+
+button.danger:hover {
+ border-color: color-mix(in srgb, var(--destructive) 70%, white);
+}
+
+button:disabled,
+a.button-link.disabled {
+ opacity: 0.5;
+ cursor: not-allowed;
+ pointer-events: none;
+}
+
+select:focus,
+input:focus,
+textarea:focus,
+button:focus-visible,
+a.button-link:focus-visible {
+ outline: 2px solid var(--ring);
+ outline-offset: 2px;
+}
+
+.status-line {
+ min-height: 28px;
+ display: inline-flex;
+ align-items: center;
+ padding: 4px 10px;
+ border: 1px solid var(--border);
+ border-radius: var(--radius);
+ background: var(--muted);
+ color: var(--muted-foreground);
+ font-size: 13px;
+}
+
+.status-line.ready {
+ border-color: var(--success);
+ background: var(--success-bg);
+ color: var(--success);
+}
+
+.status-line.error {
+ border-color: var(--destructive);
+ background: var(--error-bg);
+ color: var(--destructive);
+}
+
+@media (max-width: 768px) {
+ body { font-size: 13px; }
+ select, input, button, a.button-link { min-height: 34px; }
+}
+
+::-webkit-scrollbar {
+ width: 8px;
+ height: 8px;
+}
+::-webkit-scrollbar-track {
+ background: var(--muted);
+}
+::-webkit-scrollbar-thumb {
+ background: var(--border-strong);
+ border-radius: 4px;
+}
+::-webkit-scrollbar-thumb:hover {
+ background: var(--muted-foreground);
+}
+
+* {
+ scrollbar-width: thin;
+ scrollbar-color: var(--border-strong) var(--muted);
+}
+
+.rule {
+ width: 64px;
+ height: 4px;
+ margin-top: 0.5rem;
+ border-radius: 999px;
+ background: var(--pesu-orange);
+}
+
+.home-btn {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ width: 38px;
+ height: 38px;
+ border: 1px solid var(--border);
+ background: var(--background);
+ color: var(--muted-foreground);
+ text-decoration: none;
+ border-radius: 10px;
+ flex-shrink: 0;
+ transition: background 0.15s, color 0.15s, border-color 0.15s;
+}
+
+.home-btn svg {
+ width: 20px;
+ height: 20px;
+}
+
+.home-btn:hover {
+ background: var(--accent);
+ color: var(--foreground);
+ border-color: var(--pesu-orange);
+}
diff --git a/frontend/shared/auth-guard.js b/frontend/shared/auth-guard.js
new file mode 100644
index 0000000000000000000000000000000000000000..59ed4d1d819ae7c0906dde6cb0fef7d28faff457
--- /dev/null
+++ b/frontend/shared/auth-guard.js
@@ -0,0 +1,20 @@
+(function () {
+ document.documentElement.style.display = "none";
+ var KEY = "sb-supgrlinqgxvifijgbns-auth-token";
+ try {
+ var stored = localStorage.getItem(KEY);
+ if (!stored) {
+ window.location.href = "/auth/";
+ return;
+ }
+ var parsed = JSON.parse(stored);
+ if (!parsed || !parsed.access_token) {
+ window.location.href = "/auth/";
+ return;
+ }
+ } catch (e) {
+ window.location.href = "/auth/";
+ return;
+ }
+ document.documentElement.style.display = "";
+})();
diff --git a/frontend/shared/dialog.css b/frontend/shared/dialog.css
new file mode 100644
index 0000000000000000000000000000000000000000..9164fe766a2fe52359bc9033a4336c4caf86868f
--- /dev/null
+++ b/frontend/shared/dialog.css
@@ -0,0 +1,38 @@
+.dialog-overlay {
+ position: fixed;
+ inset: 0;
+ background: rgba(0, 0, 0, 0.5);
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ z-index: 9999;
+ opacity: 0;
+ transition: opacity 0.15s ease;
+}
+.dialog-overlay.open { opacity: 1; }
+
+.dialog-box {
+ background: var(--background);
+ border: 1px solid var(--border);
+ border-radius: var(--radius);
+ box-shadow: 0 8px 30px rgba(0, 0, 0, 0.15);
+ padding: 24px;
+ max-width: 420px;
+ width: calc(100% - 32px);
+ transform: translateY(8px);
+ transition: transform 0.15s ease;
+}
+.dialog-overlay.open .dialog-box { transform: translateY(0); }
+
+.dialog-box p {
+ margin: 0 0 20px;
+ color: var(--foreground);
+ font-size: 14px;
+ line-height: 1.5;
+}
+
+.dialog-actions {
+ display: flex;
+ justify-content: flex-end;
+ gap: 8px;
+}
diff --git a/frontend/shared/dialog.js b/frontend/shared/dialog.js
new file mode 100644
index 0000000000000000000000000000000000000000..bcf2ca20331c2d5f1a7bdd338afdc4600df62810
--- /dev/null
+++ b/frontend/shared/dialog.js
@@ -0,0 +1,42 @@
+window.showConfirm = function (message) {
+ return new Promise((resolve) => {
+ const overlay = document.createElement("div");
+ overlay.className = "dialog-overlay";
+
+ const box = document.createElement("div");
+ box.className = "dialog-box";
+
+ const p = document.createElement("p");
+ p.textContent = message;
+
+ const actions = document.createElement("div");
+ actions.className = "dialog-actions";
+
+ const cancelBtn = document.createElement("button");
+ cancelBtn.type = "button";
+ cancelBtn.textContent = "Cancel";
+ cancelBtn.addEventListener("click", () => { overlay.remove(); resolve(false); });
+
+ const confirmBtn = document.createElement("button");
+ confirmBtn.type = "button";
+ confirmBtn.className = "primary";
+ confirmBtn.textContent = "Confirm";
+ confirmBtn.addEventListener("click", () => { overlay.remove(); resolve(true); });
+
+ actions.appendChild(cancelBtn);
+ actions.appendChild(confirmBtn);
+ box.appendChild(p);
+ box.appendChild(actions);
+ overlay.appendChild(box);
+ document.body.appendChild(overlay);
+
+ requestAnimationFrame(() => overlay.classList.add("open"));
+
+ overlay.addEventListener("click", (e) => { if (e.target === overlay) { overlay.remove(); resolve(false); } });
+ document.addEventListener("keydown", function onKey(e) {
+ if (e.key === "Escape") { overlay.remove(); resolve(false); document.removeEventListener("keydown", onKey); }
+ });
+
+ confirmBtn.focus();
+ });
+};
diff --git a/frontend/shared/supabase-client.js b/frontend/shared/supabase-client.js
new file mode 100644
index 0000000000000000000000000000000000000000..00962c5baf1393f4873864ebe300d264dc58d331
--- /dev/null
+++ b/frontend/shared/supabase-client.js
@@ -0,0 +1,11 @@
+import { createClient } from 'https://cdn.jsdelivr.net/npm/@supabase/supabase-js@2/+esm';
+
+const SUPABASE_URL = 'https://supgrlinqgxvifijgbns.supabase.co';
+const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InN1cGdybGlucWd4dmlmaWpnYm5zIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODIzNjA2MjcsImV4cCI6MjA5NzkzNjYyN30.UYaQLXjBnah2YOQs65zrZskYP7Cw4CnGroYUWOrjxqg';
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+ auth: {
+ persistSession: true,
+ autoRefreshToken: true,
+ },
+});
\ No newline at end of file
diff --git a/frontend/vercel.json b/frontend/vercel.json
new file mode 100644
index 0000000000000000000000000000000000000000..104547401ae9a8d0f600b7b224c4457599b2c089
--- /dev/null
+++ b/frontend/vercel.json
@@ -0,0 +1,8 @@
+{
+ "rewrites":[
+ {
+ "source": "/api/(.*)",
+ "destination": "https://lonelyguyse1-curriculum-backend.hf.space/api/$1"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/frontend/versions.html b/frontend/versions.html
new file mode 100644
index 0000000000000000000000000000000000000000..6fcfe7cce33299478ccfe21c476bd43333d37616
--- /dev/null
+++ b/frontend/versions.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+ Loading curriculum...
+
+
+
+
+ Loading preview...
+
+
+
+
+
+
+
+ Select a version to preview its diff against the current curriculum.
+