{"id":51014931,"url":"https://github.com/nicknaskida/ai-midterm-1","last_synced_at":"2026-06-21T09:01:37.160Z","repository":{"id":355801987,"uuid":"1229664276","full_name":"NickNaskida/ai-midterm-1","owner":"NickNaskida","description":null,"archived":false,"fork":false,"pushed_at":"2026-05-05T09:22:06.000Z","size":18,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-05-05T11:19:26.539Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"HTML","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/NickNaskida.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-05-05T09:12:01.000Z","updated_at":"2026-05-05T09:22:10.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/NickNaskida/ai-midterm-1","commit_stats":null,"previous_names":["nicknaskida/ai-midterm-1"],"tags_count":null,"template":false,"template_full_name":null,"purl":"pkg:github/NickNaskida/ai-midterm-1","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NickNaskida%2Fai-midterm-1","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NickNaskida%2Fai-midterm-1/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NickNaskida%2Fai-midterm-1/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NickNaskida%2Fai-midterm-1/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/NickNaskida","download_url":"https://codeload.github.com/NickNaskida/ai-midterm-1/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NickNaskida%2Fai-midterm-1/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34603583,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-21T02:00:05.568Z","response_time":54,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-06-21T09:01:34.755Z","updated_at":"2026-06-21T09:01:37.150Z","avatar_url":"https://github.com/NickNaskida.png","language":"HTML","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Academic Transfer Planner — Documentation\n\n\u003e **Student:** Nikoloz  \n\u003e **Current Program:** Computer Science  \n\u003e **Institution:** Ilia State University  \n\u003e **Assignment:** Introduction to Artificial Intelligence — Midterm Exam\n\n---\n\n## Table of Contents\n\n1. [Project Overview](#1-project-overview)\n2. [Features](#2-features)\n3. [How to Use](#3-how-to-use)\n4. [Technical Structure](#4-technical-structure)\n5. [Equivalency Algorithm](#5-equivalency-algorithm)\n6. [Improvement Plan — AI-Powered Automatic Syllabus Comparison](#6-improvement-plan--ai-powered-automatic-syllabus-comparison)\n\n---\n\n## 1. Project Overview\n\nThe **Academic Transfer Planner** is a single-file web application that helps a Computer Science student at GTU plan a transfer to another academic program. It automatically shows which of the student's completed courses correspond to courses in the target program, generating a visual equivalency table on demand.\n\nThe application is built with pure **HTML, CSS, and JavaScript** — no frameworks, no external files, no build tools.\n\n---\n\n## 2. Features\n\n| Feature | Description |\n|---|---|\n| Course List | Auto-displayed table of all CS courses with pass status |\n| Program Display | Current program name shown prominently |\n| Program Dropdown | Select from 3 target programs |\n| Transfer Button | Generates equivalency table instantly |\n| Stats Summary | Shows pass count, matches, N/A count, and coverage % |\n\n---\n\n## 3. How to Use\n\n1. **Open** `transfer_planner.html` in any modern web browser.\n2. The course list loads automatically on page load.\n3. Select a **target program** from the dropdown menu:\n   - Computer Engineering\n   - Civil Engineering\n   - Electrical and Electronics Engineering\n4. Click the **⚡ Transfer** button.\n5. An equivalency table appears showing all passed courses matched (or not) to the target program.\n\n---\n\n## 4. Technical Structure\n\nThe entire application lives in one `.html` file with three embedded sections:\n\n```\ntransfer_planner.html\n├── \u003cstyle\u003e   — All CSS (variables, layout, animations, responsive design)\n├── \u003cbody\u003e    — HTML structure (header, cards, tables, controls)\n└── \u003cscript\u003e  — JavaScript (data, rendering, equivalency logic)\n```\n\n### Data Model\n\n```javascript\nconst myCourses = [\n  { name: \"Calculus I\",  passed: true  },\n  { name: \"Physics II\",  passed: false },\n  // ...\n];\n```\n\n### Equivalency Map Structure\n\n```javascript\nconst equivalencies = {\n  \"Computer Engineering\": {\n    \"Calculus I\": \"Calculus I\",\n    \"Machine Learning\": \"N/A\",\n    // ...\n  },\n  \"Civil Engineering\": { /* ... */ },\n  \"Electrical and Electronics Engineering\": { /* ... */ }\n};\n```\n\n---\n\n## 5. Equivalency Algorithm\n\n### Core Logic\n\nThe equivalency system uses a **rule-based lookup table** approach. Each possible target program has a pre-defined mapping dictionary that links every Computer Science course to either:\n\n- A **named equivalent course** in the target program, or\n- `\"N/A\"` if no reasonable equivalent exists.\n\nThe algorithm runs as follows:\n\n```\n1. Filter myCourses → keep only courses where passed = true\n2. For each passed course:\n   a. Look up its name in equivalencies[targetProgram]\n   b. If a match exists and is not \"N/A\" → record as equivalency\n   c. If the value is \"N/A\" → record as no equivalent\n3. Render results table + statistics\n```\n\n### Equivalency Decision Rules\n\nThe mappings were built using the following reasoning principles:\n\n**Rule 1 — Identical Name Match**  \nIf a course name is identical (or near-identical) across programs, it is a direct equivalency. Examples:\n- `Calculus I` → `Calculus I` (in Computer Engineering, EEE)\n- `English Language I` → `English Language I` (all programs)\n- `Linear Algebra` → `Linear Algebra` (all programs)\n\n**Rule 2 — Functional Equivalency**  \nIf a course covers the same core material under a different name, it is mapped as equivalent:\n- `Calculus I` (CS) → `Mathematics I` (Civil Engineering) — same content, renamed\n- `Object-Oriented Programming` (CS) → `Programming for Engineers` (EEE) — same fundamentals\n- `Probability and Statistics` (CS) → `Statistics and Probability` (Civil Eng.) — reordered title, same subject\n\n**Rule 3 — Partial Overlap → N/A**  \nIf a course only partially overlaps with anything in the target program, `N/A` is assigned to avoid misrepresentation. It is better to flag a course as unmatched than to force an inaccurate equivalency.\n\n**Rule 4 — CS-Specific Courses**  \nHighly specialized CS courses — `Machine Learning`, `Artificial Intelligence`, `Theory of Computation`, `Compiler Design`, `Human-Computer Interaction` — have no equivalents in Civil Engineering or EEE because those programs have no courses covering those topics. They are all marked `N/A` for those targets.\n\n**Rule 5 — Common Foundation Courses**  \nPhysics, Mathematics, English, and History courses are almost universally shared across all four programs at GTU and are mapped as direct equivalencies wherever they appear.\n\n### Limitations of the Current Approach\n\n- Mappings are **hardcoded** — any program curriculum change requires manual updates.\n- Equivalency is **binary**: a course is either matched or not; there is no partial credit.\n- The algorithm has **no access to actual syllabi** — it relies entirely on course names and human judgment.\n\n---\n\n## 6. Improvement Plan — AI-Powered Automatic Syllabus Comparison\n\n\u003e This chapter describes a future system where equivalency decisions are made automatically by an AI, based on the actual content of course syllabi — not course names alone.\n\n### 6.1 Motivation\n\nThe current hardcoded approach does not scale. Universities regularly update their curricula, add new courses, or rename existing ones. A name-based lookup table breaks the moment a course is renamed or a new program is introduced. More importantly, two courses with completely different names might cover the same material — and two courses with the same name might teach entirely different things. The only reliable way to determine equivalency is to read what is actually taught: the **syllabus**.\n\n### 6.2 System Architecture Overview\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│                    AI Transfer Planner v2                       │\n│                                                                 │\n│  [Syllabus Loader] → [Text Extractor] → [Embedding Engine]      │\n│                                              │                  │\n│                                    [Similarity Matcher]         │\n│                                              │                  │\n│                                    [LLM Decision Layer]         │\n│                                              │                  │\n│                                    [Equivalency Table Output]   │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n### 6.3 Step-by-Step Algorithm\n\n#### Step 1 — Syllabus Ingestion\n\nThe system automatically fetches syllabus documents for all courses in both the source and target programs. Sources could include:\n\n- University course catalog pages (scraped via HTTP)\n- PDF documents uploaded by the student or administrator\n- A structured university API (if one exists)\n\nEach syllabus is parsed to extract:\n\n```\n{\n  course_name: \"Data Structures and Algorithms\",\n  program: \"Computer Science\",\n  topics: [\"arrays\", \"linked lists\", \"trees\", \"graphs\", \"sorting\", \"complexity\"],\n  learning_outcomes: [\"implement common data structures\", \"analyze time complexity\"],\n  prerequisites: [\"Introduction to Programming\"],\n  credits: 6\n}\n```\n\n#### Step 2 — Embedding Generation\n\nEvery syllabus is converted into a **dense vector embedding** using a pre-trained language model (e.g., `text-embedding-ada-002` from OpenAI, or a local model like `all-MiniLM-L6-v2`). The embedding captures the *semantic meaning* of the course content — not just keywords.\n\n```python\n# Pseudocode\nfor course in all_courses:\n    text = course.name + \" \" + \" \".join(course.topics) + \" \" + \" \".join(course.outcomes)\n    course.embedding = embedding_model.encode(text)\n```\n\n#### Step 3 — Similarity Matching\n\nFor each passed course in the source program, the system computes **cosine similarity** against every course in the target program:\n\n```\nsimilarity(A, B) = cos(embedding_A, embedding_B)\n                 = (A · B) / (|A| × |B|)\n```\n\nCourses are ranked by similarity. The top candidate is proposed as the equivalent. A similarity threshold (e.g., `0.75`) determines whether a match is \"strong enough\" to count as an equivalency.\n\n```\nCalculus I (CS)  →  similarity scores:\n  Mathematics I (Civil)        → 0.94  ✓ Match\n  Physics I (Civil)            → 0.61\n  Structural Analysis (Civil)  → 0.21\n```\n\n#### Step 4 — LLM Verification Layer\n\nFor borderline cases (similarity between `0.55` and `0.75`), a **Large Language Model** is called to make the final decision. It receives both syllabi as input and is prompted:\n\n```\nSystem: You are an academic advisor determining course equivalency for university transfer.\n\nUser: \n  Course A — \"Object-Oriented Programming\" (Computer Science):\n  Topics: classes, inheritance, polymorphism, design patterns, Java\n  Outcomes: design and implement OOP systems\n\n  Course B — \"Programming for Engineers\" (Electrical Engineering):\n  Topics: procedural programming, basic OOP, C++, embedded systems\n  Outcomes: write structured programs for engineering applications\n\n  Are these courses equivalent? Answer: YES / PARTIAL / NO\n  Reason: [one sentence]\n```\n\nThe LLM output (`YES`, `PARTIAL`, `NO`) + its reasoning is shown to the student so they can understand and verify the decision.\n\n#### Step 5 — Output\n\nThe system generates a final equivalency table with confidence levels:\n\n| Your Course | Equivalent | Confidence | Basis |\n|---|---|---|---|\n| Calculus I | Mathematics I | 94% | Syllabus similarity |\n| OOP | Programming for Engineers | 71% | LLM verified |\n| Machine Learning | N/A | — | No match above threshold |\n\n### 6.4 Why AI Helps\n\n| Task | Manual Approach | AI Approach |\n|---|---|---|\n| Reading syllabi | Human reads dozens of PDFs | Automated extraction in seconds |\n| Finding matches | Name-based guessing | Semantic understanding of actual content |\n| Borderline decisions | Subjective human judgment | Explainable LLM reasoning |\n| Handling renames | Breaks immediately | Unaffected — based on content, not names |\n| Scaling to new programs | Manual update of all tables | Automatic — just load new syllabi |\n\n### 6.5 Technologies Involved\n\n- **PDF/HTML parsing:** `PyMuPDF`, `BeautifulSoup`\n- **Embedding model:** `sentence-transformers` (local) or OpenAI API\n- **Vector similarity:** `numpy`, `scikit-learn`, or a vector database like `ChromaDB`\n- **LLM for verification:** `Claude`, `GPT-4`, or a local model via `Ollama`\n- **Frontend:** Updated version of the current single-file HTML app, calling a lightweight Python backend (Flask/FastAPI)\n\n### 6.6 Example Workflow (User Perspective)\n\n1. Student opens the improved Transfer Planner.\n2. Selects their current program and the target program.\n3. Clicks **\"Auto-Compare Syllabi\"**.\n4. The system fetches syllabi, runs embeddings, computes similarity.\n5. Within ~10 seconds, a complete equivalency table appears with confidence scores and AI reasoning.\n6. Student can click any row to see a side-by-side syllabus comparison.\n7. The student exports the result as a PDF to submit to the academic office.\n\nThis approach transforms course transfer planning from a slow, bureaucratic process into an instant, evidence-based, AI-assisted workflow.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnicknaskida%2Fai-midterm-1","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnicknaskida%2Fai-midterm-1","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnicknaskida%2Fai-midterm-1/lists"}