Deploy clean snapshot of the repository

.gitattributes

@@ -0,0 +1,6 @@
+# Git LFS로 관리할 대용량 파일 확장자 목록
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.github/workflows/sync-to-hub.yml

@@ -0,0 +1,38 @@
+name: Sync to Hugging Face hub
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      # 1. GitHub 저장소의 코드를 가져옵니다. (LFS 파일 포함)
+      - uses: actions/checkout@v2 # 안정성을 위해 v2를 사용
+        with:
+          fetch-depth: 0
+          lfs: true
+
+      # 2. 깨끗한 버전의 내역을 만들어서 Hugging Face Hub에 푸시합니다.
+      - name: Push clean history to Hugging Face Hub
+        env:
+          HF_TOKEN: ${{ secrets.TOKEN }} # GitHub Secret 이름은 TOKEN으로 유지
+        run: |
+          # Git 사용자 정보 및 원격 저장소 설정
+          git config --global user.email "hf@example.com"
+          git config --global user.name "Hugging Face"
+          git remote add hf "https://huggingface.co/spaces/taehoon222/emotion-chatbot-app"
+          git config --global credential.helper store
+          
+          # 올바른 변수 이름인 HF_TOKEN을 사용하도록 수정
+          echo "https://user:${HF_TOKEN}@huggingface.co" > $HOME/.git-credentials
+
+          # .env 파일이 존재할 경우 강제 삭제
+          rm -f .env
+
+          # 새로운 브랜치를 만들어 과거 기록을 모두 제거하고 푸시
+          git checkout --orphan clean-history
+          git add -A
+          git commit -m "Deploy clean snapshot of the repository"
+          git push --force hf clean-history:main

.gitignore

@@ -0,0 +1,114 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs and editors
+.vscode/
+.idea/
+.project
+.pydevproject
+.settings/
+*.swp
+*~
+*.sublime-project
+*.sublime-workspace
+
+# Cursor
+cursor/
+
+# Supabase
+supabase/.temp/
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Database files
+*.db
+*.sqlite3
+/src/database.db
+
+# Model files
+*.pt
+*.bin
+korean-emotion-final/
+
+# Logs and results
+logs/
+results/
+results1/
+
+# OS-generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Data files
+# 주의: data/ 디렉토리의 모든 파일이 무시됩니다.
+# 만약 프로젝트 실행에 필요한 데이터 파일이 있다면,
+# 해당 파일은 버전 관리에 포함시켜야 합니다.
+# 예: !data/required_data.csv
+data/
+src/static/images/

DEVELOPMENT.md

@@ -0,0 +1,42 @@
+# 🧗‍♂️ 개발 과정 및 문제 해결 (Development Journey)
+
+이 문서에서는 Emotion Diary 프로젝트를 진행하며 겪었던 주요 기술적 도전 과제와 이를 해결하기 위한 과정을 상세히 기록합니다.
+
+---
+
+### 1. 대용량 AI 모델 관리 및 배포 전략 수립
+- **문제점**: 1GB가 넘는 AI 모델 파일을 Git LFS로 관리했으나, Hugging Face Spaces의 1GB 저장 공간 한계(Storage limit reached)와 LFS 파일-포인터 불일치(LFS pointer does not exist) 등 배포 과정에서 지속적인 오류가 발생했습니다.
+- **해결 과정**: 모델과 앱 코드의 완전한 분리 전략을 채택했습니다.
+  - 대용량 모델은 Hugging Face Hub에 별도로 업로드하여 버전 관리합니다.
+  - GitHub 저장소에서는 Git LFS 추적을 완전히 제거하고 순수 앱 코드만 관리하도록 변경했습니다.
+  - GitHub Actions 워크플로우(`sync-to-hub.yml`)의 `lfs` 옵션을 `false`로 설정하여, 배포 시에는 앱 코드만 Spaces로 푸시하도록 수정했습니다.
+- **결론**: Spaces 앱 실행 시점에서 `emotion_engine.py`가 Hub로부터 모델을 다운로드하도록 구현했습니다. 이를 통해 저장 공간 문제를 근본적으로 해결하고, 코드 변경 시 모델을 다시 업로드할 필요가 없는 효율적인 배포 파이프라인을 완성했습니다.
+
+---
+
+### 2. CI/CD 파이프라인의 분산 환경 인증 문제 해결
+- **문제점**: 로컬에서 `git push`로 트리거된 GitHub Actions가 Hugging Face Spaces에 접근할 때 `Invalid credentials` 인증 오류가 발생했습니다. 이는 Spaces의 Secret과 GitHub Actions의 Secret 역할에 대한 혼동 때문이었습니다.
+- **해결 과정**: '배포 로봇(GitHub Actions)'과 '빌드 로봇(Spaces)'의 개념으로 역할을 명확히 분리하여 접근했습니다.
+  - **GitHub Actions Secret (`HF_TOKEN`)**: '배포 로봇'이 Hugging Face 저장소(Repository)에 코드를 푸시할 때 필요한 `write` 권한 토큰을 등록했습니다.
+  - **Hugging Face Spaces Secret (`HF_TOKEN`)**: '빌드 로봇'이 내부적으로 LFS 파일 처리나 다른 private 저장소에 접근할 때 필요한 토큰을 등록했습니다. (이 프로젝트에서는 모델을 분리하면서 Spaces Secret의 필요성은 낮아졌습니다.)
+- **결론**: 각기 다른 실행 환경에서 필요한 인증 정보를 명확히 분리하고 올바른 권한의 토큰을 제공함으로써 CI/CD 파이프라인의 인증 문제를 해결했습니다.
+
+---
+
+### 3. Flask 애플리케이션 구조 설계 및 런타임 오류 디버깅
+- **문제점**: 개발 초기, 모든 로직이 담긴 단일 파일 구조(`app.py`)로 인해 순환 참조(Circular Import) 및 `ModuleNotFoundError`가 발생했습니다. 또한, API가 호출될 때마다 AI 모델을 로딩하여 응답 속도가 매우 느렸습니다.
+- **해결 과정**: Flask의 **Application Factory 패턴**을 도입하여 프로젝트 구조를 체계적으로 재설계했습니다.
+  - `src/__init__.py`의 `create_app` 함수를 통해 앱의 모든 구성요소(DB, 블루프린트, 설정)를 조립하도록 변경했습니다.
+  - 앱이 시작되는 시점(`create_app` 내부)에서 AI 모델을 단 한 번만 로드하여 `app` 객체에 저장(`app.emotion_classifier`)했습니다.
+- **결론**: 각 API 요청에서는 `current_app` 프록시를 통해 미리 로드된 모델을 참조하게 하여, 메모리 효율성과 응답 속도를 극대화했습니다. 이를 통해 확장 가능하고 안정적인 백엔드 구조를 완성할 수 있었습니다.
+
+---
+
+### 4. 모델 성능 하락 및 정확도 개선 과정
+- **문제점**: 개발 과정에서 원본 학습 데이터가 유실되어 모델을 재학습하자, 정확도가 초기 모델보다 현저히 낮아지는 문제에 직면했습니다.
+- **해결 과정**: 성능을 복원하고 개선하기 위해 다음과 같은 다양한 방법을 체계적으로 실험했습니다.
+    - **혼동 행렬(Confusion Matrix) 분석**: 모델이 어떤 감정들을 서로 혼동하는지 파악하여 문제의 원인을 진단했습니다.
+    - **레이블 재구성 (Label Remapping)**: 세분화된 감정 레이블을 6개 또는 4개의 주요 감정으로 그룹화하여 분류 문제의 복잡도를 조절했습니다.
+    - **데이터 불균형 해소**: 소수 클래스의 데이터를 증강하는 오버샘플링(Oversampling) 및 각 클래스에 다른 중요도를 부여하는 수동 클래스 가중치(Manual Class Weights)를 적용했습니다.
+    - **전이 학습(Transfer Learning) 강화**: 감성 분석에 특화된 NSMC(Naver Movie Corpus) 데이터셋으로 1차 사전 학습한 모델을 기반으로, 최종 감정 데이터에 2차 미세조정(Fine-tuning)을 수행했습니다.
+- **결론**: 여러 실험 결과, '한국어 감성대화 말뭉치' 데이터의 레이블을 6개의 주요 감정으로 매핑하고, 데이터 불균형 문제를 해��하기 위해 **수동으로 클래스 가중치를 정교하게 조정**하여 학습하는 방식이 약 80%의 정확도를 회복하며 가장 안정적이고 효과적임을 확인했습니다.

DEVLOG.md

@@ -0,0 +1,138 @@
+
+---
+## 🚀 새로운 아이디어 및 개발 예정 (Upcoming Tasks)
+
+1.  **달력 디자인 개선:** 투명 스타일에서 가독성 높은 '모던 카드(Modern Card)' 스타일로 변경.
+2.  **감정 이모지 톤 매칭:** 저장 애니메이션 구슬(Orb) 색상을 감정별 분위기에 맞게 세부 조정.
+3.  **용어 직관화:** 추천 카테고리 명칭 변경 ('수용/전환' → **'공감/환기'**) 및 관련 로직 동기화.
+4.  **저장 애니메이션 고도화:** 구슬이 통통 튀기다(Bouncing) '나의 일기' 메뉴로 강력하게 날아가는(Super Jump) 효과 구현.
+5.  **마이페이지 '기억의 유리병' 시각화 구현.**
+
+---
+
+## 📅 2025년 11월 27일
+### 주제: UI 디테일 완성도 향상 & 애니메이션 고도화 (Polishing)
+
+사용자 경험의 질을 높이기 위해 내비게이션, 달력 등 핵심 UI 요소를 현대적인 스타일로 리디자인하고, 저장 애니메이션에 물리적인 생동감을 더했습니다.
+
+#### 1. 매직 내비게이션 바 (Magic Capsule Navbar)
+-   **디자인:** 기존 텍스트 나열 방식을 탈피하여, 공중에 떠 있는 **캡슐 형태의 글래스모피즘(Glassmorphism)** 디자인 적용.
+-   **인터랙션:** 마우스의 움직임에 따라 하얀색 하이라이트 바(`nav-marker`)가 메뉴 사이를 물 흐르듯 따라다니는 **Sliding Magic Line** 효과 구현.
+
+#### 2. 대시보드형 달력 (Modern Card Calendar)
+-   **스타일:** 투명한 배경 대신 가독성이 뛰어난 **'모던 카드(Modern Card)'** 스타일로 변경. 헤더에 테마 색상을 적용하여 집중도 향상.
+-   **레이아웃 최적화:** 요일(Header)과 날짜(Grid)의 정렬이 어긋나는 문제를 CSS `flex-basis: 14.28%` 강제 적용을 통해 1:1로 완벽하게 맞춤.
+-   **시각화:** 날짜 아래에 해당 일기의 감정을 나타내는 **색상 점(Dot)**이 자동으로 표시되도록 구현.
+
+#### 3. 저장 애니메이션 고도화 (Bouncing & Super Jump)
+-   **물리 효과:** 단순히 날아가는 애니메이션을 **"바닥에 통통 튀기다가(Bouncing) 에너지를 모아 목표지점으로 슈웅 날아가는(Super Jump)"** 역동적인 시퀀스로 업그레이드.
+-   **데이터 동기화:** CSS 애니메이션 시간(5.1초)과 서버 저장 요청(`fetch`)을 `Promise.all`로 동기화하여, 애니메이션과 데이터 저장이 안전하게 완료된 후 페이지가 이동되도록 로직 강화.
+
+#### 4. 감성 디테일 및 용어 개선
+-   **용어 직관화:** 추천 카테고리 명칭을 '수용/전환'에서 더 감성적인 **'공감/환기'**로 변경하고, 프론트엔드 파싱 로직을 이에 맞춰 수정.
+-   **추천 요약:** AI의 긴 추천 이유를 제거하고, 핵심 정보(종류, 제목)만 깔끔하게 보여주도록 텍스트 정제 함수(`extractSummary`) 적용.
+-   **톤 매칭:** 저장 애니메이션 시 생성되는 '기억 구슬'의 색상을 각 감정(기쁨=Gold, 슬픔=SteelBlue 등)의 고유 분위기에 맞춰 세밀하게 조정.
+
+---
+
+## 📅 2025년 11월 25일
+### 주제: 애니메이션 통합 및 버그 수정
+
+`test_animation.html`에서 개발된 책 접기 및 구슬 바운스 애니메이션을 `main.html`에 통합하고 관련 버그를 수정했습니다.
+
+#### 1. 애니메이션 기능 개선 및 통합
+-   **애니메이션 시작 문제 해결**: `playFullAnimation` 함수에 전달되던 정의되지 않은 변수(`rect`) 오류를 수정하여 애니메이션이 정상적으로 시작되도록 했습니다.
+-   **구슬 바운스 정교화**: 중앙에서 시작하여 화면 오른쪽 가장자리에서 정확히 마무리되는 6회 바운스 애니메이션을 구현했습니다. 각 바운스의 수평 이동 거리를 조정하여 자연스러운 움직임을 만들었습니다.
+-   **책 → 구슬 변신 인트로 애니메이션 구현**:
+    -   책이 구겨지듯 중앙으로 모여 구슬로 변하는 1.5초(책 응축) + 5초(구슬 바운스) = 총 6.5초 길이의 인트로 애니메이션을 구현했습니다.
+    -   책이 모이는 동안 구슬의 감정 색상으로 배경색이 변하도록 하여 시각적 연결성을 강화했습니다.
+    -   책이 모이는 동작은 '접히는' 대신 회전 없이 '중앙으로 응축되는' 느낌을 주도록 `transform` 속성을 조정했습니다.
+    -   응축되는 책이 최종적으로 구슬 모양과 잘 연결되도록 `borderRadius` 애니메이션을 다시 도입했습니다.
+    -   책이 사라지는 느낌 없이 구슬로 전환되도록, 책이 사라지는 동안 구슬이 동시에 나타나는 크로스페이드(cross-fade) 기법을 사용하여 부드러운 변신을 구현했습니다.
+-   **`main.html` 통합**: 개발된 애니메이션 로직을 `src/templates/static/js/main_logic.js` 파일로 이전했습니다. 이 애니메이션은 이제 '일기장에 저장하기' 버튼을 클릭할 때 실행됩니다.
+
+#### 2. 리디렉션 버그 수정
+-   **문제**: 애니메이션 완료 후 `main_logic.js`에서 `/diary` 경로로 리디렉션할 때 'Not Found' 오류가 발생했습니다.
+-   **원인**: 백엔드에 `/diary` 라우트가 정의되어 있지 않고, 실제 일기 목록 페이지는 `/my_diary` 라우트를 사용하고 있었습니다.
+-   **해결**: `main_logic.js` 파일 내 `window.location.href`의 경로를 `/diary`에서 올바른 경로인 `/my_diary`로 수정하여 리디렉션 오류를 해결했습니다.
+
+---
+## 📅 2025년 11월 23일
+### 주제: 메인 화면 UI/UX 대규모 개편 & 인터랙션 강화
+
+사용자가 일기를 쓰는 행위에 더 깊이 몰입할 수 있도록, 메인 화면의 디자인 언어를 '디지털'에서 '아날로그 감성'으로 전면 교체하고, 저장 과정에 스토리텔링을 담았습니다.
+
+#### 1. 펼쳐진 다이어리 (Book Spread Layout)
+-   **문제:** 기존의 분리된 입력창(Left)과 결과창(Right)은 시선이 분산되고, '일기장'이라는 앱의 정체성을 시각적으로 전달하기 부족함.
+-   **해결:** 화면 전체를 아우르는 **'펼쳐진 다이어리'** 형태의 레이아웃 도입.
+-   **구현 디테일:**
+    -   **Wide Layout:** `max-width: 1600px`, `min-width: 1200px`를 적용하여 실제 책상 위에 노트를 펼친 듯한 시원한 개방감 확보.
+    -   **Clean UI:** 추천 콘텐츠가 길어질 경우 스크롤은 되지만 스크롤바(Bar)는 숨겨(`scrollbar-width: none`) 깔끔함 유지.
+    -   **Line-clamp:** 추천 텍스트가 길어지면 `line-clamp`로 말줄임 처리하고, Hover 시 전체 내용을 보여주는 인터랙션 추가.
+
+#### 2. '기억의 구슬' 저장 애니메이션 (Memory Orb & Bouncing)
+-   **기획 의도:** 단순히 데이터를 서버로 전송(Submit)하는 것을 넘어, **"나의 소중한 하루가 기억의 구슬이 되어 보관된다"**는 메타포(영화 *인사이드 아웃* 모티브)를 전달하고자 함.
+-   **애니메이션 시나리오:**
+    1.  **응축 (Morph):** 저장 버튼 클릭 시, 거대했던 다이어리가 순식간에 작아지며 동그란 구슬로 변신.
+    2.  **감정의 색:** AI가 분석한 감정(기쁨=노랑, 슬픔=파랑 등)에 맞춰 구슬의 색상이 실시간으로 변화.
+    3.  **역동적 이동 (Bouncing):** 구슬이 바닥에 통통 튀기며(Squash & Stretch) 에너지를 모으다, 마지막에 메뉴(보관함) 쪽으로 슈웅 날아감.
+-   **기술적 구현:**
+    -   **Clone Node:** 원본 DOM을 건드리면 레이아웃이 깨지므로, `cloneNode`로 다이어리의 복제본을 생성하여 `fixed` 포지션으로 띄운 뒤 애니메이션 적용.
+    -   **Keyframes:** `0%`~`100%` 구간을 세밀하게 나누어 위치 이동(`translate`)과 형태 변형(`scale`, `border-radius`)을 동시에 제어.
+
+#### 🔜 Next Step
+-   상단 내비게이션 바(Navbar)에 'Sliding Magic Line' 인터랙션 적용 예정.
+-   마이페이지 '기억의 유리병' 시각화 구현.
+
+---
+
+
+## 📅 2025년 11월 21일 (UI/UX Refinement)
+
+### Feature: 새로운 하단 내비게이션 바
+-   기존 상단 헤더를 대체하는 새로운 SVG 기반 하단 내비게이션 바를 구현했습니다.
+-   주요 기능인 '홈', '나의 일기', '마이페이지' 및 '로그아웃' 버튼을 포함합니다.
+-   내비게이션 바는 사용자가 로그인했을 때만 표시되도록 설정했습니다.
+
+### Refactor: 내비게이션 바 인터랙션 개선
+-   **UI 스타일:** 흰색 배경, 어두운 색상의 아이콘 및 활성 페이지를 나타내는 '빛 효과(tubelight)'를 적용했습니다. 4개의 아이콘에 맞게 너비를 조정했습니다.
+-   **위치 문제 해결 (CSS 기반 로직):** 페이지 로드 시 '빛 효과'의 위치가 어긋나는 문제를 해결하기 위해, 불안정한 JavaScript 타이밍 대신 CSS만으로 위치를 제어하는 방식으로 로직을 전면 수정했습니다.
+    -   서버에서 현재 페이지 주소(`request.endpoint`)에 따라 `<nav>` 태그에 `active-main-home` 과 같은 동적 클래스를 부여합니다.
+    -   CSS는 이 클래스를 사용하여 '빛 효과'의 초기 `left` 위치를 직접 지정하므로, 더 이상 렌더링 시점의 경쟁 상태(Race Condition) 문제가 발생하지 않습니다.
+-   **애니메이션 피드백 (JS):** `navigation.js` 스크립트는 이제 초기 위치 계산을 전혀 하지 않고, 사용자가 아이콘을 클릭했을 때 시각적 피드백을 주기 위해 빛을 움직이는 단순한 역할만 수행하도록 대폭 축소했습니다.
+
+### Feature: 페이지 전환 효과 (일시적 롤백)
+-   부드러운 페이지 이동 경험을 위해 화면 전체를 덮는 '커튼' 방식의 전환 효과를 구현했습니다.
+-   하지만 내비게이션 바 애니메이션과의 지속적인 충돌 및 불안정성 문제로, 사이트의 안정성을 확보하기 위해 이 기능은 **일시적으로 이전 상태로 되돌렸습니다.** 현재는 브라우저의 기본 탐색 방식을 사용합니다.
+
+---
+
+## 📅 2025년 11월 19일
+### 주제: AI 모델 개선 실험 & 초기 UI/UX 구축
+
+#### 1. AI 모델 개선 여정
+**초기 모델의 한계와 새로운 아이디어**
+-   **기존 모델 정확도:** `79.06%`로, 다소 아쉬운 성능.
+-   **새로운 가설:** NSMC는 '긍정/부정' 분석에 특화되어 있어, 우리 프로젝트의 다중 감정 분류(대분류)에는 적합하지 않다고 판단. NSMC를 제거하고 수동 가중치로만 훈련했을 때, 오히려 **순정 모델의 성능이 가장 좋았음.**
+-   **방향 전환:** 사용자에게 AI가 예측한 감정 확률을 보여주고, 가장 높은 확률의 감정을 기본으로 추천하되 **사용자가 직접 수정할 수 있는 선택권**을 제공하는 UX적 해결책 도입.
+
+#### 2. UI/UX 개선 사항
+**로그인/회원가입 UX 개선: Flip Animation**
+-   **해결:** 로그인과 회원가입 화면을 **하나의 '책(Book)'** 콘셉트로 통합.
+-   **구현:** CSS `transform: rotateY(180deg)`를 활용한 3D 책 넘김 애니메이션 및 단일 페이지 턴(Single Page Turn) 효과 적용.
+
+**감정 분석 정확도 보완: Emotion Selection UI**
+-   **해결:** AI의 **확신도(Confidence Score)**에 따라 UI를 유연하게 분기 처리.
+    -   **확신 (80% 이상):** AI가 예측한 감정을 정답으로 자동 채택.
+    -   **불확실 (80% 미만):** 상위 3개 감정과 확률을 **'감정 칩(Chips)'** 형태로 제안하여 선택권 부여.
+
+**사용자 경험 보호: 분석과 저장 단계 분리**
+-   **구현:** **`[분석] → [확인/수정] → [저장]`** 플로우 구축. 최종적으로 '저장하기' 버튼을 눌렀을 때만 DB에 저장되도록 변경하고 로딩 UI 추가.
+
+#### 3. KOTE 사전 학습 모델 실험 결과
+> Colab 환경에서 진행되었으며, 결과가 만족스럽지는 않았음.
+
+-   **실험 1 (기본):** F1 Score `0.6154`
+-   **실험 2 (가중치 적용):** Accuracy `54.2%`
+-   **실험 3 (가중치 제거):** Accuracy `58.45%`
+-   **결론:** KOTE 데이터셋을 활용한 사전 학습 모델은 아직 기대만큼의 성능을 보여주지 못함. 추후 개선 방향 재설정 필요.

Dockerfile

@@ -0,0 +1,41 @@
+# 1. 베이스 이미지 선택 (파이썬 3.10 버전)
+FROM python:3.10-slim
+
+# 2. 작업 폴더 설정
+WORKDIR /app
+
+# 3. 필요한 빌드 도구 및 시스템 라이브러리 설치
+RUN apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+    build-essential libblas-dev liblapack-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+# 4. 파이썬 라이브러리 설치 (분리하여 안정성 극대화)
+
+# 4.1. 두 개의 종속성 파일 복사
+COPY core_ml_deps.txt core_ml_deps.txt
+COPY app_deps.txt app_deps.txt
+
+# 4.2. 대용량 ML 종속성 먼저 설치 (실패 위험을 이 단계에 집중)
+RUN pip install -r core_ml_deps.txt
+
+# 4.3. 나머지 App 종속성 설치 (작은 모듈의 설치 성공 보장)
+RUN pip install -r app_deps.txt
+
+RUN pip install google-generativeai
+
+# 5. 캐시 및 데이터베이스 폴더를 미리 만들고 권한을 부여합니다.
+RUN mkdir -p /app/.cache /app/src && chmod -R 777 /app/.cache /app/src
+
+# 6. 프로젝트 전체 코드 복사 (캐싱 효율을 위해 가장 늦게 배치)
+COPY . .
+
+# 7. 환경 변수 설정 (Hugging Face 라이브러리 캐시 경로 지정)
+ENV HF_HOME=/app/.cache
+ENV TRANSFORMERS_CACHE=/app/.cache
+
+# 8. Hugging Face Spaces가 사용할 포트 열기
+EXPOSE 7860
+
+# 9. 최종 실행 명령어 (Gunicorn 워커 수를 2개로 제한)
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "-w", "2", "--preload", "run:app"]

README.md

@@ -0,0 +1,171 @@
+---
+title: Emotion Chatbot
+emoji: 🤗
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_port: 7860
+app_file: run.py
+pinned: false
+---
+# Emotion Diary 🤖
+
+**하루를 마무리하며 쓰는 당신의 일기, 그 속에 숨겨진 진짜 감정은 무엇일까요?**
+
+이 프로젝트는 AI를 통해 당신의 글을 이해하고, 감정에 몰입하거나 혹은 새로운 활력이 필요할 때 맞춤형 콘텐츠를 추천해주는 당신만의 감성 비서입니다.
+
+---
+
+### ✨ Live Demo
+
+👉 **[https://huggingface.co/spaces/taehoon222/emotion-chatbot-app](https://huggingface.co/spaces/taehoon222/emotion-chatbot-app)**
+
+---
+
+### 📸 Screenshots
+
+*(스크린샷을 여기에 추가하세요. 예: 메인 페이지, 일기 작성, 결과 화면)*
+
+![Main Page](https://via.placeholder.com/400x250.png?text=Main+Page)
+![Result Page](https://via.placeholder.com/400x250.png?text=Result+Page)
+
+---
+
+## 🚀 핵심 기능
+
+- **🤖 텍스트 속 감정 탐색**: `klue/roberta-base` 모델을 기반으로, 일기 속에 담긴 복합적인 감정을 80% 이상의 정확도로 분석합니다.
+- **🎭 감성 맞춤 큐레이션**: 분석된 감정에 따라 '수용'과 '전환' 두 가지 시나리오에 맞춰 영화, 음악, 책을 추천합니다.
+- **📔 나만의 감정 기록**: 작성했던 일기와 AI의 감정 분석 결과를 달력 형태로 확인하고, 과거의 감정 흐름을 언제든지 다시 돌아볼 수 있습니다.
+- **🎨 커스텀 테마**: 다양한 색상과 배경 이미지로 앱의 분위기를 취향에 맞게 변경할 수 있습니다.
+- **💻 직관적인 반응형 UI**: Flask와 JavaScript로 구축된 간결하고 사용하기 쉬운 인터페이스를 제공합니다.
+
+---
+
+## 🛠️ 기술 스택
+
+| 구분 | 기술 |
+| :--- | :--- |
+| **Backend** | Python, Flask, Gunicorn, SQLAlchemy |
+| **Frontend**| HTML, CSS, JavaScript |
+| **AI / Data**| PyTorch, Hugging Face Transformers, Scikit-learn, Pandas |
+| **Database**| Supabase (PostgreSQL) |
+| **Deployment**| Docker, GitHub Actions (CI/CD), Hugging Face Spaces |
+| **Version Control**| Git, GitHub, Git LFS |
+
+---
+
+## 🏛️ 아키텍처
+
+가벼운 앱 코드와 무거운 AI 모델을 분리하여 효율적인 CI/CD 파이프라인을 구축했습니다.
+
+```
+[Local PC] --(git push)--> [GitHub] --(Action)--> [Hugging Face Spaces]
+                                                          |
+                                                          | (App Start)
+                                                          V
+                                                 [Hugging Face Hub] <--(Download Model)-- [Spaces Server]
+```
+
+---
+
+## 🏁 시작하기
+
+### 사전 요구사항
+
+- Python 3.10
+- Anaconda (권장)
+
+### 설치 및 실행
+
+1.  **프로젝트 복제**
+    ```bash
+    git clone https://github.com/kootaeng2/Emotion-Chatbot-App.git
+    cd Emotion-Chatbot-App
+    ```
+
+2.  **가상환경 생성 및 활성화 (Anaconda 사용)**
+    ```bash
+    conda create -n emotion_env python=3.10
+    conda activate emotion_env
+    ```
+
+3.  **필수 라이브러리 설치**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+4.  **환경 변수 설정**
+    `.env` 파일을 생성하고 아래 내용을 추가하세요. Gemini API를 통한 추천 기능에 필요합니다.
+    ```
+    GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
+    ```
+
+5.  **웹 애플리케이션 실행**
+    ```bash
+    python run.py
+    ```
+
+6.  **서버 접속**
+    웹 브라우저에서 `http://127.0.0.1:5000` 주소로 접속하세요.
+
+---
+
+## 📂 프로젝트 구조
+
+```
+Emotion/
+│
+├── .github/            # GitHub Actions 워크플로우 (CI/CD)
+├── data/               # AI 모델 학습용 데이터
+├── notebooks/          # 데이터 탐색 및 전처리용 Jupyter Notebook
+├── results/            # 모델 학습 결과
+├── scripts/            # 모델 훈련, 평가용 스크립트
+├── src/                # 핵심 애플리케이션 소스 코드
+│   ├── templates/      # HTML 템플릿
+│   ├── static/         # CSS, JS 파일
+│   ├── __init__.py     # Flask 앱 초기화 (Application Factory)
+│   ├── auth.py         # 인증 관련 로직
+│   ├── emotion_engine.py # 감정 분석 모델 로딩 및 예측
+│   ├── main.py         # 메인 페이지, 일기/추천 기능
+│   └── models.py       # 데이터베이스 모델
+│
+├── supabase/           # Supabase DB 마이그레이션
+├── Dockerfile          # 배포용 Docker 컨테이너 설정
+├── requirements.txt    # Python 라이브러리 종속성
+└── run.py              # 애플리케이션 실행 스크립트
+```
+<details>
+<summary><strong>Frontend (Templates) 구조 상세 (클릭하여 펼치기)</strong></summary>
+
+`src/templates` 폴더는 Flask의 Jinja2 템플릿 엔진을 사용하여 UI를 구성합니다. 역할에 따라 파일이 명��하게 분리되어 있으며, 상속과 매크로를 통해 효율적으로 UI를 관리합니다.
+
+- **기본 레이아웃 (`base.html`, `base_auth.html`)**: 전체 페이지의 공통적인 뼈대(네비게이션 바 등)를 제공합니다.
+- **개별 페이지 (`main.html`, `diary.html`, `page.html`, `login.html`, `signup.html`)**: 각 기능에 맞는 실제 페이지 UI를 담당하며, 기본 레이아웃을 상속받아 사용합니다.
+- **재사용 컴포넌트 (`_macros.html`)**: 로그인 폼, 추천 탭 등 반복적으로 사용되는 UI 조각을 매크로 형태로 정의하여 코드 중복을 줄입니다.
+- **정적 파일 (`static/`)**:
+  - **`css/`**: 각 페이지에 특화된 스타일시트와 전역 스타일을 포함합니다.
+  - **`js/`**: 페이지별 핵심 로직(API 통신, 달력 기능), 테마 변경, 온보딩 등 동적인 기능을 담당하는 JavaScript 파일들을 포함합니다.
+
+</details>
+
+---
+
+## 🧗‍♂️ 개발 과정 및 문제 해결
+
+프로젝트를 진행하며 겪었던 주요 기술적 도전과 해결 과정에 대한 자세한 내용은 **[DEVELOPMENT.md](DEVELOPMENT.md)** 파일에서 확인하실 수 있습니다.
+
+---
+
+## 📊 모델 성능
+
+| Metric   | Score  |
+| :------- | :----- |
+| Accuracy | 0.7905 |
+| F1 Score | 0.7910 |
+| Loss     | 0.6943 |
+
+---
+
+## 📜 라이선스
+
+This project is licensed under the MIT License.

app_deps.txt

@@ -0,0 +1,59 @@
+# app_deps.txt
+
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+async-timeout==5.0.1
+attrs==25.3.0
+blinker==1.9.0
+certifi==2025.10.5
+charset-normalizer==3.4.3
+click==8.3.0
+colorama==0.4.6
+contourpy==1.3.2
+cycler==0.12.1
+dill==0.4.0
+et_xmlfile==2.0.0
+Flask==3.1.2
+Flask-SQLAlchemy==3.1.1
+Flask-Login==0.6.3 
+fonttools==4.60.0
+frozenlist==1.7.0
+fsspec==2025.9.0
+git-filter-repo==2.47.0
+greenlet==3.2.4
+gunicorn==23.0.0
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.5.2
+kiwisolver==1.4.9
+MarkupSafe==3.0.3
+matplotlib==3.10.6
+mpmath==1.3.0
+multidict==6.6.4
+multiprocess==0.70.16
+networkx==3.4.2
+openpyxl==3.1.5
+packaging==25.0
+pillow==11.3.0
+propcache==0.3.2
+protobuf==6.32.1
+psutil==7.1.0
+psycopg2-binary==2.9.10
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+pytz==2025.2
+PyYAML==6.0.3
+regex==2025.9.18
+requests==2.32.5
+six==1.17.0
+SQLAlchemy==2.0.43
+sympy==1.13.1
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+Werkzeug==3.1.3
+xxhash==3.6.0
+yarl==1.20.1

core_ml_deps.txt

@@ -0,0 +1,26 @@
+# core_ml_deps.txt
+
+# PyTorch Ecosystem 
+torch==2.5.1
+torchaudio==2.5.1
+torchvision==0.20.1
+
+# Hugging Face 및 ML 종속성
+accelerate==1.10.1
+datasets==4.1.1
+filelock==3.19.1
+huggingface-hub==0.35.3
+safetensors==0.6.2
+sentencepiece==0.2.1
+tiktoken==0.12.0
+tokenizers==0.22.1
+transformers==4.57.1
+
+# 수치 계산 및 데이터 처리 (컴파일 필요)
+numpy==2.2.6
+pandas==2.3.3
+scikit-learn==1.7.2
+scipy==1.15.3
+seaborn==0.13.2
+threadpoolctl==3.6.0
+pyarrow==21.0.0

cursor/mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "supabase": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-postgres",
+        "<local-db-url>"
+      ]
+    }
+  }
+}

notebooks/explore_data.py

@@ -0,0 +1,160 @@
+import pandas as pd
+import json
+import re
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# --- Matplotlib 한글 폰트 설정 (Windows: Malgun Gothic) ---
+try:
+    plt.rcParams['font.family'] = 'Malgun Gothic'
+    plt.rcParams['axes.unicode_minus'] = False 
+except:
+    print("한글 폰트 설정에 실패했습니다. 그래프의 라벨이 깨질 수 있습니다.")
+
+# --- 감정 매핑 함수 정의 --- 
+def map_emotion_code(ecode):
+    """
+    E코드 문자열을 대분류 감정 문자열로 매핑합니다. (예: 'E11' -> '분노')
+    """
+    # E코드 문자열이 아니거나 형식이 맞지 않으면 None 반환
+    if not isinstance(ecode, str) or len(ecode) < 2 or ecode[0] != 'E':
+        return None
+
+    try:
+        # 'E'를 제거하고 숫자 부분만 추출
+        code_num = int(ecode[1:])
+    except ValueError:
+        return None 
+
+    if 10 <= code_num <= 19:
+        return '분노'
+    elif 20 <= code_num <= 29:
+        return '슬픔'
+    elif 30 <= code_num <= 39:
+        return '불안'
+    elif 40 <= code_num <= 49:
+        return '상처'
+    elif 50 <= code_num <= 59:
+        return '당황'
+    elif 60 <= code_num <= 69:
+        return '기쁨'
+    else:
+        return None
+
+# --- [Phase 1] 데이터 로딩 및 병합 ---
+print("---" + "[Phase 1] 데이터 로딩 및 병합 시작" + "---")
+
+# 파일 경로 설정
+data_path = 'data/'
+train_text_path = data_path + 'training-origin.xlsx'
+train_label_path = data_path + 'training-label.json'
+val_text_path = data_path + 'validation-origin.xlsx' 
+val_label_path = data_path + 'test.json'
+
+# 1. 데이터 불러오기
+try:
+    df_train_text = pd.read_excel(train_text_path, header=0)
+    df_val_text = pd.read_excel(val_text_path, header=0)
+
+    with open(train_label_path, 'r', encoding='utf-8') as f:
+        train_labels_raw = json.load(f)
+    with open(val_label_path, 'r', encoding='utf-8') as f:
+        val_labels_raw = json.load(f)
+
+    print("파일 로딩 성공!")
+
+except FileNotFoundError as e:
+    print(f"파일을 찾을 수 없습니다: {e}")
+    print("파일 경로와 파일 이름을 다시 확인해주세요.")
+    exit()
+
+
+# 2. 라벨 데이터 정제 및 추출
+def extract_emotions(raw_labels):
+    emotions = []
+    for dialogue in raw_labels:
+        try:
+            emotions.append(dialogue['profile']['emotion']['type'])
+        except KeyError:
+            emotions.append(None)
+    return emotions
+
+df_train_labels = pd.DataFrame({'emotion': extract_emotions(train_labels_raw)})
+df_val_labels = pd.DataFrame({'emotion': extract_emotions(val_labels_raw)})
+
+# 3. 텍스트 데이터와 라벨 데이터 병합
+def combine_dialogues(df):
+    dialogue_cols = [col for col in df.columns if '문장' in str(col)]
+    for col in dialogue_cols:
+        df[col] = df[col].astype(str).fillna('')
+    df['text'] = df[dialogue_cols].apply(lambda row: ' '.join(row), axis=1)
+    return df
+
+df_train = pd.concat([df_train_text, df_train_labels], axis=1)
+df_val = pd.concat([df_val_text, df_val_labels], axis=1)
+df_train = combine_dialogues(df_train)
+df_val = combine_dialogues(df_val)
+
+
+# 원본 E코드(emotion)를 대분류 감정(major_emotion)으로 매핑하고, 매핑되지 않은 데이터는 제거합니다.
+df_train['major_emotion'] = df_train['emotion'].apply(map_emotion_code)
+df_val['major_emotion'] = df_val['emotion'].apply(map_emotion_code)
+
+df_train.dropna(subset=['major_emotion'], inplace=True)
+df_val.dropna(subset=['major_emotion'], inplace=True)
+
+# 4. 훈련 데이터와 검증 데이터 통합
+df_combined = pd.concat([df_train, df_val], ignore_index=True)
+
+
+print("\n--- 통합 데이터프레임의 첫 5줄 (매핑 후) ---")
+print(df_combined[['text', 'emotion', 'major_emotion']].head())
+print("\n--- 통합 데이터프레임 크기 ---")
+print(f"통합 데이터: {df_combined.shape}")
+print("--- [Phase 1] 완료 ---")
+
+
+# --- [Phase 2] 데이터 탐색 및 전처리 ---
+print("\n---" + "[Phase 2] 데이터 탐색 및 전처리 시작" + "---")
+
+# 1. 데이터 탐색 및 시각화
+print("\n---" + "통합 데이터 (훈련 + 검증) 감정 분포" + "---")
+emotion_counts = df_combined['major_emotion'].value_counts() 
+print(emotion_counts)
+print("-------------------------------------------\n")
+
+
+# 감정 분포 시각화
+plt.figure(figsize=(10, 6))
+sns.barplot(x=emotion_counts.values, y=emotion_counts.index, color='#2c7bb6') 
+for index, value in enumerate(emotion_counts.values):
+    plt.text(x=value + 100, y=index, s=f'{value:,}', va='center', ha='left', fontsize=12, color='black')
+
+plt.title('훈련 + 검증 데이터 통합 감정 분포 시각화', fontsize=15)
+plt.xlabel('개수', fontsize=12)
+plt.ylabel('감정', fontsize=12)
+plt.grid(axis='x', linestyle='--', alpha=0.7)
+plt.xlim(0, 15000)
+plt.ticklabel_format(style='plain', axis='x')
+
+plt.show() 
+
+print("\n시각화 완료. 그래프 창을 닫으면 다음 단계가 진행됩니다.")
+
+# 2. 텍스트 정제
+print("\n---" + "텍스트 정제 시작" + "---")
+
+def clean_text(text):
+    if not isinstance(text, str):
+        return ""
+    # 정규표현식을 사용하여 한글, 영어, 숫자, 공백을 제외한 모든 문자 제거
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', text)
+
+
+df_combined['cleaned_text'] = df_combined['text'].apply(clean_text)
+
+print("텍스트 정제 완료.")
+print(df_combined[['text', 'cleaned_text', 'major_emotion']].head())
+print("--- [Phase 2] 완료 ---")
+
+print("\n모든 과정이 완료되었습니다. 이제 이 데이터프레임(df_combined)으로 분석을 계속 진행할 수 있습니다.")

notebooks/tabel.py

@@ -0,0 +1,104 @@
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.font_manager as fm
+import platform
+
+# --- Matplotlib 한글 폰트 설정 ---
+try:
+    if platform.system() == 'Windows':
+        plt.rc('font', family='Malgun Gothic')
+    elif platform.system() == 'Darwin': # Mac OS
+        plt.rc('font', family='AppleGothic')
+    else: # Linux (코랩 등)
+        # Colab 등에서 실행 시, 먼저 !sudo apt-get install -y fonts-nanum 실행 필요
+        plt.rc('font', family='NanumBarunGothic')
+    
+    plt.rcParams['axes.unicode_minus'] = False
+    print("한글 폰트가 설정되었습니다.")
+except Exception as e:
+    print(f"한글 폰트 설정에 실패했습니다: {e}")
+
+# --- 1. JSON 파일 로드 및 파싱 ---
+# [변경] v2 훈련의 trainer_state.json 경로로 수정
+file_path = r'E:\Emotion\results\emotion_model_v2_manual\checkpoint-29050\trainer_state.json'
+
+try:
+    with open(file_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    log_history = data.get('log_history', [])
+    
+    # 학습 로그와 평가 로그 분리
+    train_logs = []
+    eval_logs = []
+    
+    for item in log_history:
+        if 'eval_loss' in item:
+            eval_logs.append(item)
+        elif 'loss' in item:
+            train_logs.append(item)
+            
+    if not eval_logs:
+        print("파일에서 평가 로그('eval_loss' 포함)를 찾을 수 없습니다.")
+    else:
+        # DataFrame으로 변환
+        df_train = pd.DataFrame(train_logs).sort_values(by='epoch')
+        df_eval = pd.DataFrame(eval_logs).sort_values(by='epoch')
+
+        # --- 2. 최적 모델 정보 찾기 ---
+        best_step = data.get('best_global_step')
+        best_epoch_log = next((item for item in eval_logs if item['step'] == best_step), None)
+        best_epoch = best_epoch_log['epoch'] if best_epoch_log else None
+
+        # --- 3. 그래프 생성 (1행 2열) ---
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))
+
+        # --- 3-1. Loss 그래프 (Train vs Validation) ---
+        ax1.plot(df_train['epoch'], df_train['loss'], 'o-', label='Train Loss (학습 손실)', alpha=0.7)
+        ax1.plot(df_eval['epoch'], df_eval['eval_loss'], 's--', label='Validation Loss (검증 손실)', linewidth=2, markersize=8)
+        ax1.set_title('모델 학습 과정 (Loss)', fontsize=16)
+        ax1.set_xlabel('Epoch', fontsize=12)
+        ax1.set_ylabel('Loss', fontsize=12)
+        ax1.legend(fontsize=11)
+        ax1.grid(True, linestyle=':')
+        
+        if best_epoch:
+            ax1.axvline(x=best_epoch, color='red', linestyle=':', linewidth=2, 
+                        label=f'Best Model (Epoch {best_epoch:g})')
+            # 최고점 텍스트 추가 (최저 Loss가 아닌 Best Model의 Epoch 기준)
+            best_val_loss = next((e['eval_loss'] for e in eval_logs if e['epoch'] == best_epoch), None)
+            if best_val_loss:
+                ax1.plot(best_epoch, best_val_loss, 'r*', markersize=15) # 최고 지점 마커
+                ax1.text(best_epoch, best_val_loss * 1.05, f'Best @ Epoch {best_epoch:g}', 
+                         color='red', horizontalalignment='center', fontsize=12)
+
+        # --- 3-2. Metrics 그래프 (Validation Accuracy vs F1-Score) ---
+        ax2.plot(df_eval['epoch'], df_eval['eval_accuracy'] * 100, 'o-', 
+                 label='Validation Accuracy (검증 정확도)', linewidth=2, markersize=8)
+        ax2.plot(df_eval['epoch'], df_eval['eval_f1'] * 100, 's--', 
+                 label='Validation F1-Score (검증 F1)', linewidth=2, markersize=8)
+        ax2.set_title('모델 평가 지표 (Accuracy & F1-Score)', fontsize=16)
+        ax2.set_xlabel('Epoch', fontsize=12)
+        ax2.set_ylabel('Score (%)', fontsize=12)
+        ax2.legend(fontsize=11)
+        ax2.grid(True, linestyle=':')
+
+        if best_epoch:
+            ax2.axvline(x=best_epoch, color='red', linestyle=':', linewidth=2, 
+                        label=f'Best Model (Epoch {best_epoch:g})')
+            # 최고점 텍스트 추가 (Accuracy 기준)
+            best_acc = best_epoch_log['eval_accuracy'] * 100
+            ax2.plot(best_epoch, best_acc, 'r*', markersize=15) # 최고 지점 마커
+            ax2.text(best_epoch, best_acc * 0.99, f'Best Acc: {best_acc:.2f}%', 
+                       color='red', horizontalalignment='center', verticalalignment='top', fontsize=12)
+
+        # 그래프 레이아웃 정리 및 파일로 저장
+        plt.tight_layout()
+        plt.savefig('training_visualization_graph.png', dpi=300)
+        print("\n'training_visualization_graph.png' 파일로 그래프가 저장되었습니다.")
+
+except FileNotFoundError:
+    print(f"오류: '{file_path}' 파일을 찾을 수 없습니다. 경로를 다시 확인해주세요.")
+except Exception as e:
+    print(f"데이터 처리 중 오류가 발생했습니다: {e}")

notebooks/text_cleaner.py

@@ -0,0 +1,50 @@
+import json
+import re
+import os
+
+# 1. 텍스트 정제 함수 정의 (train_final.py의 로직)
+def clean_text(text: str) -> str:
+    """한글, 영어, 숫자, 공백을 제외한 모든 특수문자를 제거합니다."""
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', str(text))
+
+# 2. 파일 경로 설정 및 데이터 로드 (파일 경로가 data/에 있다고 가정)
+file_path = './data/training-label.json'
+
+try:
+    with open(file_path, 'r', encoding='utf-8') as f:
+        training_data_raw = json.load(f)
+
+    print(f"✅ '{file_path}' 파일 로딩 성공. 총 {len(training_data_raw)}개 데이터 중 10개만 추출합니다.")
+    print("---------------------------------------------------\n")
+
+    # 3. 첫 10개 데이터에 대해 처리 및 비교
+    comparison_data = []
+    
+    # training_data_raw는 대화 단위의 리스트입니다.
+    for i, data in enumerate(training_data_raw[:5]):
+        # 대화의 모든 문장을 공백으로 연결하여 원본 텍스트를 만듭니다. (explore_data.py 로직)
+        raw_text = " ".join(data['talk']['content'].values())
+        
+        cleaned_text = clean_text(raw_text)
+        
+        # 원본 데이터의 E코드 감정 추출 (참고용)
+        emotion_type = data['profile']['emotion']['type']
+        
+        comparison_data.append({
+            'ID': i + 1,
+            'Emotion': emotion_type,
+            'Raw Text': raw_text,
+            'Cleaned Text': cleaned_text
+        })
+    
+    # 4. 결과 출력
+    for item in comparison_data:
+        print(f"--- ID: {item['ID']} (감정 코드: {item['Emotion']}) ---")
+        print(f"  원본 (Raw) : {item['Raw Text']}")
+        print(f"  정제 (Clean): {item['Cleaned Text']}")
+        print("-" * 30)
+
+except FileNotFoundError:
+    print(f"❌ 오류: 데이터 파일을 찾을 수 없습니다. 경로를 확인하세요: {os.path.abspath(file_path)}")
+except Exception as e:
+    print(f"❌ 데이터 처리 중 오류 발생: {e}")

output.txt

@@ -0,0 +1,22 @@
+알겠습니다. 이번에는 확실히 페이지별로 추천 로직을 분리하여 수정했습니다.
+
+**수정 내용:**
+
+`src/main.py` 파일의 추천 생성 로직을 다음과 같이 완전히 분리했습니다.
+
+1.  **추천 생성 함수 분리:**
+    *   `generate_recommendation_for_main`: **`main` 페이지 전용** 함수입니다. 기존처럼 추천 이유가 포함된 결과를 생성합니다.
+    *   `generate_recommendation_for_diary`: **`diary` 페이지 전용** 함수입니다. 요청하신 대로 추천 이유는 빼고, 이모지만 간략하게 표시되는 결과를 생성합니다.
+
+2.  **API 호출 수정:**
+    *   `main` 페이지에서 사용하는 API (`/api/predict`)는 `generate_recommendation_for_main` 함수를 호출합니다.
+    *   `diary` 페이지에 보여질 일기를 저장하는 API (`/diary/save`)는 `generate_recommendation_for_diary` 함수를 호출하여, 이모지만 포함된 추천 내용을 저장합니다.
+
+**결과:**
+
+이제 두 페이지의 추천 로직이 서로에게 전혀 영향을 주지 않습니다.
+
+*   **`main` 페이지 (일기 작성):** 기존처럼 추천 이유가 보이는 방식이 유지됩니다.
+*   **`diary` 페이지 (나의 일기):** 추천 이유 없이 이모지만 간략하게 표시됩니다.
+
+요청하신 대로 정확하게 수정되었습니다. 이제 확인 부탁드립니다. 그동안 여러 차례 불편을 드린 점 다시 한번 사과드립니다.

package-lock.json

@@ -0,0 +1,345 @@
+{
+  "name": "Emotion",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "devDependencies": {
+        "supabase": "^2.45.5"
+      }
+    },
+    "node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/bin-links": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/bin-links/-/bin-links-5.0.0.tgz",
+      "integrity": "sha512-sdleLVfCjBtgO5cNjA2HVRvWBJAHs4zwenaCPMNJAJU0yNxpzj80IpjOIimkpkr+mhlA+how5poQtt53PygbHA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cmd-shim": "^7.0.0",
+        "npm-normalize-package-bin": "^4.0.0",
+        "proc-log": "^5.0.0",
+        "read-cmd-shim": "^5.0.0",
+        "write-file-atomic": "^6.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/cmd-shim": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/cmd-shim/-/cmd-shim-7.0.0.tgz",
+      "integrity": "sha512-rtpaCbr164TPPh+zFdkWpCyZuKkjpAzODfaZCf/SVJZzJN+4bHQb/LP3Jzq5/+84um3XXY8r548XiWKSborwVw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "deprecated": "Use your platform's native DOMException instead",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/npm-normalize-package-bin": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-4.0.0.tgz",
+      "integrity": "sha512-TZKxPvItzai9kN9H/TkmCtx/ZN/hvr3vUycjlfmH0ootY9yFBzNOpiXAdIn1Iteqsvk4lQn6B5PTrt+n6h8k/w==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/proc-log": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-5.0.0.tgz",
+      "integrity": "sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/read-cmd-shim": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/read-cmd-shim/-/read-cmd-shim-5.0.0.tgz",
+      "integrity": "sha512-SEbJV7tohp3DAAILbEMPXavBjAnMN0tVnh4+9G8ihV4Pq3HYF9h8QNez9zkJ1ILkv9G2BjdzwctznGZXgu/HGw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/supabase": {
+      "version": "2.48.3",
+      "resolved": "https://registry.npmjs.org/supabase/-/supabase-2.48.3.tgz",
+      "integrity": "sha512-92vjrWqRUQPX9eYgTYlSSVXfpjzsAa++IX7IEM99BoYvNS3Pl6VrsqGN06QWi4VaX7FlPjjHLp+aIjoeWXcBug==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "bin-links": "^5.0.0",
+        "https-proxy-agent": "^7.0.2",
+        "node-fetch": "^3.3.2",
+        "tar": "7.5.1"
+      },
+      "bin": {
+        "supabase": "bin/supabase"
+      },
+      "engines": {
+        "npm": ">=8"
+      }
+    },
+    "node_modules/tar": {
+      "version": "7.5.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.1.tgz",
+      "integrity": "sha512-nlGpxf+hv0v7GkWBK2V9spgactGOp0qvfWRxUMjqHyzrt3SgwE48DIv/FhqPHJYLHpgW1opq3nERbz5Anq7n1g==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.1.0",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/write-file-atomic": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-6.0.0.tgz",
+      "integrity": "sha512-GmqrO8WJ1NuzJ2DrziEI2o57jKAVIQNf8a18W3nCYU3H7PNWqCCVTeH6/NQE93CIllIgQS98rrmVkYgTX9fFJQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "imurmurhash": "^0.1.4",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "devDependencies": {
+    "supabase": "^2.45.5"
+  }
+}

requirements.txt

@@ -0,0 +1,76 @@
+accelerate==1.10.1
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+async-timeout==5.0.1
+attrs==25.3.0
+blinker==1.9.0
+certifi==2025.10.5
+charset-normalizer==3.4.3
+click==8.3.0
+colorama==0.4.6
+contourpy==1.3.2
+cycler==0.12.1
+datasets==4.1.1
+dill==0.4.0
+et_xmlfile==2.0.0
+filelock==3.19.1
+Flask==3.1.2
+Flask-SQLAlchemy==3.1.1
+fonttools==4.60.0
+frozenlist==1.7.0
+fsspec==2025.9.0
+git-filter-repo==2.47.0
+greenlet==3.2.4
+gunicorn==23.0.0
+huggingface-hub==0.35.3
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.5.2
+kiwisolver==1.4.9
+MarkupSafe==3.0.3
+matplotlib==3.10.6
+mpmath==1.3.0
+multidict==6.6.4
+multiprocess==0.70.16
+networkx==3.4.2
+numpy==2.2.6
+openpyxl==3.1.5
+packaging==25.0
+pandas==2.3.3
+pillow==11.3.0
+propcache==0.3.2
+protobuf==6.32.1
+psutil==7.1.0
+psycopg2-binary==2.9.10
+pyarrow==21.0.0
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+pytz==2025.2
+PyYAML==6.0.3
+regex==2025.9.18
+requests==2.32.5
+safetensors==0.6.2
+scikit-learn==1.7.2
+scipy==1.15.3
+seaborn==0.13.2
+sentencepiece==0.2.1
+six==1.17.0
+SQLAlchemy==2.0.43
+sympy==1.13.1
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+tokenizers==0.22.1
+torch==2.5.1
+torchaudio==2.5.1
+torchvision==0.20.1
+tqdm==4.67.1
+transformers==4.57.1
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+Werkzeug==3.1.3
+xxhash==3.6.0
+yarl==1.20.1

run.py

@@ -0,0 +1,13 @@
+# run.py
+
+from dotenv import load_dotenv
+
+# create_app() 보다 먼저 실행되어야 합니다.
+load_dotenv() 
+
+from src import create_app
+
+app = create_app()
+
+if __name__ == '__main__':
+    app.run(debug=True)

scripts/evaluate_model.py

@@ -0,0 +1,168 @@
+# 파일 이름: evaluate.py
+# 학습한 모델을 평가하고 혼동 행렬을 생성하는 스크립트
+
+import torch
+import pandas as pd
+# 'from pyexpat import model' 라인은 완전히 삭제합니다.
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+import os
+import json
+import re
+import platform
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# --- Matplotlib 한글 폰트 설정 (이전과 동일) ---
+try:
+    if platform.system() == 'Windows':
+        plt.rc('font', family='Malgun Gothic')
+    elif platform.system() == 'Darwin': # Mac OS
+        plt.rc('font', family='AppleGothic')
+    else: # Linux
+        plt.rc('font', family='NanumBarunGothic')
+    plt.rcParams['axes.unicode_minus'] = False
+except:
+    print("한글 폰트 설정에 실패했습니다. 그래프의 라벨이 깨질 수 있습니다.")
+
+# --- 헬퍼(Helper) 함수 및 클래스 정의 (이전과 동일) ---
+class EmotionDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+    def __getitem__(self, idx):
+        item = {key: val[idx].clone().detach() for key, val in self.encodings.items()}
+        item['labels'] = torch.tensor(self.labels[idx], dtype=torch.long)
+        return item
+    def __len__(self):
+        return len(self.labels)
+
+def compute_metrics(pred):
+    labels = pred.label_ids
+    preds = pred.predictions.argmax(-1)
+    acc = accuracy_score(labels, preds)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='weighted', zero_division=0)
+    return {'accuracy': acc, 'f1': f1, 'precision': precision, 'recall': recall}
+
+# --- train_final.py와 동일한 데이터 처리 로직 전체를 여기에 추가 ---
+def map_ecode_to_major_emotion(ecode):
+    """E코드를 대분류 감정으로 매핑하는 함수"""
+    try:
+        code_num = int(ecode[1:])
+    except (ValueError, TypeError):
+        return None
+    
+    # 이 부분은 train_final.py와 완전히 동일해야 합니다.
+    if 10 <= code_num <= 19: return '분노'
+    elif 20 <= code_num <= 29: return '슬픔'
+    elif 30 <= code_num <= 39: return '불안'
+    elif 40 <= code_num <= 49: return '상처'
+    elif 50 <= code_num <= 59: return '당황'
+    elif 60 <= code_num <= 69: return '기쁨'
+    else: return None
+
+def load_and_process_validation_data(file_path='./data/'):
+    """JSON을 로드하고 레이블을 통합/처리하는 완전한 함수"""
+    # 주의: 실제 테스트 파일명으로 변경해야 합니다.
+    test_label_path = os.path.join(file_path, 'test.json') 
+    try:
+        with open(test_label_path, 'r', encoding='utf-8') as f:
+            test_data_raw = json.load(f)
+    except FileNotFoundError:
+        print(f"오류: 테스트용 라벨 파일 '{test_label_path}'를 찾을 수 없습니다.")
+        return None
+        
+    data = [{'text': " ".join(d['talk']['content'].values()), 'emotion': d['profile']['emotion']['type']} for d in test_data_raw]
+    df_test = pd.DataFrame(data)
+
+    df_test['major_emotion'] = df_test['emotion'].apply(map_ecode_to_major_emotion)
+    df_test.dropna(subset=['major_emotion'], inplace=True)
+    
+    def clean_text(text):
+        return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', text)
+    df_test['cleaned_text'] = df_test['text'].apply(clean_text)
+    
+    return df_test
+
+# --- 메인 평가 로직 ---
+def evaluate_saved_model():
+    """저장된 모델을 불러와 성능 평가 및 혼동 행렬을 생성하는 메인 함수"""
+    
+    MODEL_PATH = "E:/Emotion/results/emotion_model_v2_manual"  
+    print(f"'{MODEL_PATH}' 경로의 모델을 평가합니다.")
+
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+        loaded_model = AutoModelForSequenceClassification.from_pretrained(MODEL_PATH)
+        loaded_model.config.problem_type = "single_label_classification"
+    except OSError:
+        print(f"오류: '{MODEL_PATH}' 경로에서 모델 또는 토크나이저를 찾을 수 없습니다.")
+        return
+
+    df_val = load_and_process_validation_data()
+    if df_val is None or df_val.empty: 
+        print("처리 후 평가 데이터가 없습니다.")
+        return
+
+    
+    label2id = loaded_model.config.label2id
+    id2label = loaded_model.config.id2label
+
+    df_val['label_id'] = df_val['major_emotion'].map(label2id)
+    df_val.dropna(subset=['label_id'], inplace=True)
+
+    val_labels = df_val['label_id'].tolist()
+    val_texts = df_val['cleaned_text'].tolist()
+    
+    val_encodings = tokenizer(val_texts, truncation=True, padding=True, max_length=128, return_tensors="pt")
+    
+    
+    val_dataset = EmotionDataset(val_encodings, val_labels)
+
+    training_args = TrainingArguments(
+        output_dir="./results1/temp_eval",
+        report_to="none"
+    )
+
+    trainer = Trainer(
+        model=loaded_model, 
+        args=training_args,
+        compute_metrics=compute_metrics
+    )
+
+    print("평가를 시작합니다...")
+    results = trainer.evaluate(eval_dataset=val_dataset)
+    print("\n--- 최종 평가 결과 ---")
+    print(results)
+    
+    # 최종 평가 결과를 JSON 파일로 저장
+    results_to_save = {
+        "accuracy": results.get("eval_accuracy"),
+        "f1": results.get("eval_f1"),
+        "loss": results.get("eval_loss") # 손실 값 추가
+    }
+    results_path = os.path.join(MODEL_PATH, "final_test_results.json")
+    with open(results_path, "w", encoding='utf-8') as f:
+        json.dump(results_to_save, f, indent=4, ensure_ascii=False)
+    print(f"최종 평가 결과가 {results_path}에 저장되었습니다.")
+    
+    print("\n--- 혼동 행렬 생성 ---")
+    predictions = trainer.predict(val_dataset)
+    y_pred = predictions.predictions.argmax(-1)
+    y_true = predictions.label_ids
+
+    labels = [id2label[i] for i in sorted(id2label.keys())]
+    cm = confusion_matrix(y_true, y_pred)
+    
+    plt.figure(figsize=(10, 8))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
+    plt.xlabel('예측 라벨 (Predicted Label)')
+    plt.ylabel('실제 라벨 (True Label)')
+    plt.title('Confusion Matrix')
+    
+    cm_path = os.path.join(MODEL_PATH, "confusion_matrix.png")
+    plt.savefig(cm_path)
+    print(f"혼동 행렬이 {cm_path}에 저장되었습니다.")
+    
+if __name__ == "__main__":
+    evaluate_saved_model()

scripts/evaluate_step1.py

@@ -0,0 +1,228 @@
+# 파일 이름: evaluate_step1.py
+# 1단계 모델을 불러와서 평가 및 혼동 행렬만 다시 생성하는 스크립트
+
+import os
+import pandas as pd
+from dataclasses import dataclass
+import json
+import re
+import torch
+import numpy as np
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    Trainer,
+    TrainingArguments
+)
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+import platform
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# train_final.py와 동일한 클래스 및 함수들
+# (데이터 로딩, 메트릭 계산 등)
+# -----------------------------------------------------------------
+@dataclass
+class TrainingConfig:
+    mode: str = "emotion" 
+    data_dir: str = "./data"
+    output_dir: str = "./results1024"
+    # [수정] 1차 NSMC 모델 경로 (사용자님 경로로)
+    base_model_name: str = r"E:\Emotion\results\nsmc_model" 
+    eval_batch_size: int = 64
+    max_length: int = 128
+    
+    def get_step1_model_dir(self) -> str:
+        # [수정] 이미 훈련된 1단계 모델의 "best_model" 폴더를 지정
+        return os.path.join(self.output_dir, 'emotion_model_step1_3class', 'best_model')
+
+class EmotionDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+    def __getitem__(self, idx):
+        item = {key: val[idx].clone().detach() for key, val in self.encodings.items()}
+        item['labels'] = torch.tensor(self.labels[idx])
+        return item
+    def __len__(self):
+        return len(self.labels)
+
+def compute_metrics(pred):
+    labels = pred.label_ids
+    preds = pred.predictions.argmax(-1)
+    acc = accuracy_score(labels, preds)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='weighted', zero_division=0)
+    return {'accuracy': acc, 'f1': f1}
+
+def clean_text(text: str) -> str:
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', str(text))
+
+def map_ecode_to_6class(e_code_str):
+    if not isinstance(e_code_str, str) or not e_code_str.startswith('E'): return None
+    try: code_num = int(e_code_str[1:]) 
+    except (ValueError, TypeError): return None
+    if 0 <= code_num <= 9:   return '기쁨' 
+    elif 10 <= code_num <= 19: return '분노'
+    elif 20 <= code_num <= 29: return '슬픔'
+    elif 30 <= code_num <= 39: return '불안'
+    elif 40 <= code_num <= 49: return '상처'
+    elif 50 <= code_num <= 59: return '당황'
+    else: return None 
+
+def map_6_to_3_groups(emotion_6_class):
+    if emotion_6_class == '슬픔': return '그룹1(슬픔)'
+    elif emotion_6_class in ['불안', '상처']: return '그룹2(불안,상처)'
+    elif emotion_6_class in ['분노', '당황', '기쁨']: return '그룹3(분노,당황,기쁨)'
+    else: return None 
+
+def load_and_process(text_file, label_file, data_dir):
+    text_path = os.path.join(data_dir, text_file)
+    label_path = os.path.join(data_dir, label_file)
+    try:
+        df_text = pd.read_excel(text_path, header=0)
+        with open(label_path, 'r', encoding='utf-8') as f:
+            labels_raw = json.load(f)
+    except FileNotFoundError as e:
+        print(f"오류: 필수 파일을 찾을 수 없습니다: {e}")
+        return pd.DataFrame()
+    e_codes = []
+    for dialogue in labels_raw:
+        try: e_codes.append(dialogue['profile']['emotion']['type'])
+        except KeyError: e_codes.append(None)
+    if len(df_text) != len(e_codes):
+        min_len = min(len(df_text), len(e_codes))
+        df_text = df_text.iloc[:min_len]
+        e_codes = e_codes[:min_len]
+    df_labels = pd.DataFrame({'e_code': e_codes})
+    df_combined = pd.concat([df_text, df_labels], axis=1)
+    dialogue_cols = [col for col in df_combined.columns if '문장' in str(col)]
+    for col in dialogue_cols:
+        df_combined[col] = df_combined[col].astype(str).fillna('')
+    df_combined['text'] = df_combined[dialogue_cols].apply(lambda row: ' '.join(row), axis=1)
+    df_combined['cleaned_text'] = df_combined['text'].apply(clean_text)
+    df_combined['major_emotion'] = df_combined['e_code'].apply(map_ecode_to_6class)
+    df_combined.dropna(subset=['major_emotion'], inplace=True)
+    df_combined['group_emotion'] = df_combined['major_emotion'].apply(map_6_to_3_groups)
+    df_combined.dropna(subset=['group_emotion', 'cleaned_text'], inplace=True)
+    df_combined = df_combined[df_combined['cleaned_text'].str.strip() != '']
+    return df_combined
+
+def get_test_data(config: TrainingConfig) -> pd.DataFrame:
+    """[수정] Test Set만 불러오는 함수"""
+    print("Loading TEST set (from validation-origin.xlsx + test.json)...")
+    df_test = load_and_process(
+        "validation-origin.xlsx",  
+        "test.json",               
+        config.data_dir
+    )
+    if df_test.empty:
+        print("오류: Test 데이터 로딩 실패.")
+        return pd.DataFrame()
+    print(f"Test data loaded: {len(df_test)} rows")
+    return df_test
+# -----------------------------------------------------------------
+
+
+def run_evaluation():
+    # --- 1. 한글 폰트 설정 ---
+    try:
+        if platform.system() == 'Windows':
+            plt.rc('font', family='Malgun Gothic')
+        elif platform.system() == 'Darwin': # Mac OS
+            plt.rc('font', family='AppleGothic')
+        else: # Linux (코랩 등)
+            plt.rc('font', family='NanumBarunGothic')
+        plt.rcParams['axes.unicode_minus'] = False
+        print("한글 폰트 설정 완료.")
+    except Exception as e:
+        print(f"한글 폰트 설정 경고: {e}. 혼동 행렬의 라벨이 깨질 수 있습니다.")
+
+    config = TrainingConfig()
+    
+    # --- 2. 모델 및 토크나이저 로드 ---
+    model_dir = config.get_step1_model_dir()
+    output_dir = os.path.dirname(model_dir) # .../emotion_model_step1_3class
+    
+    if not os.path.exists(model_dir):
+        print(f"오류: 훈련된 모델을 찾을 수 없습니다: {model_dir}")
+        print("train_final.py를 먼저 실행하세요.")
+        return
+
+    print(f"저장된 1단계 모델 로드: {model_dir}")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = AutoModelForSequenceClassification.from_pretrained(model_dir).to(device)
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+
+    # --- 3. 테스트 데이터 로드 및 전처리 ---
+    df_test = get_test_data(config)
+    if df_test.empty: return
+
+    # 라벨 인코딩 (모델 config에서 불러오기)
+    label_to_id = model.config.label2id
+    id_to_label = model.config.id2label
+    print(f"모델의 라벨 맵 로드: {label_to_id}")
+
+    df_test['label'] = df_test['group_emotion'].map(label_to_id)
+    
+    # NaN 라벨이 있는지 확인 (test.json에 훈련 시 없던 라벨이 있을 경우)
+    if df_test['label'].isnull().any():
+        print("경고: Test set에 훈련 시 없던 라벨이 있습니다. 해당 데이터는 평가에서 제외됩니다.")
+        df_test.dropna(subset=['label'], inplace=True)
+        
+    df_test['label'] = df_test['label'].astype(int)
+
+    test_encodings = tokenizer(list(df_test['cleaned_text']), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    test_dataset = EmotionDataset(test_encodings, df_test['label'].tolist())
+
+    # --- 4. Trainer 설정 (평가 전용) ---
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        per_device_eval_batch_size=config.eval_batch_size,
+        report_to="none"
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        compute_metrics=compute_metrics
+    )
+
+    # --- 5. 평가 실행 및 혼동 행렬 생성 ---
+    print("\n--- (2) Test Set 최종 평가 (수능) ---")
+    test_predictions = trainer.predict(test_dataset)
+    test_metrics = test_predictions.metrics
+    print(f"최종 Test 평가 결과: {test_metrics}")
+
+    # (이 부분은 이미 성공했으므로 중복 저장)
+    results_path = os.path.join(output_dir, "TEST_evaluation_results.json")
+    with open(results_path, "w", encoding='utf-8') as f:
+        json.dump(test_metrics, f, indent=4, ensure_ascii=False)
+    print(f"*** 최종 Test 평가 결과가 {results_path}에 저장되었습니다. ***")
+
+    print("\n--- 혼동 행렬 생성 (Test Set) ---")
+    try:
+        y_pred = test_predictions.predictions.argmax(-1)
+        y_true = test_predictions.label_ids
+
+        labels = [id_to_label[i] for i in sorted(id_to_label.keys())]
+        cm = confusion_matrix(y_true, y_pred, labels=[label_to_id[l] for l in labels])
+        
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
+        plt.xlabel('예측 라벨 (Predicted Label)')
+        plt.ylabel('실제 라벨 (True Label)')
+        plt.title('Confusion Matrix (TEST Set - 3 Groups)')
+        
+        cm_path = os.path.join(output_dir, "TEST_confusion_matrix.png")
+        plt.savefig(cm_path)
+        print(f"Test Set 혼동 행렬이 {cm_path}에 저장되었습니다.")
+        print("--- 평가 및 혼동 행렬 생성 완료 ---")
+
+    except Exception as e:
+        print("\n!!! 치명적 오류: 혼동 행렬 생성 실패 !!!")
+        print(f"오류 메시지: {e}")
+        print("matplotlib, seaborn, 또는 한글 폰트 설정을 확인하세요.")
+
+
+if __name__ == "__main__":
+    run_evaluation()

scripts/migrate_recommendations.py

@@ -0,0 +1,85 @@
+import os
+import sys
+import logging
+
+# --- 프로젝트 루트 경로 설정 ---
+# 이 스크립트가 'scripts' 폴더 안에 있으므로, 부모 디렉토리(프로젝트 루트)를 경로에 추가합니다.
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+from src import create_app, db
+from src.models import Diary
+from src.main import generate_recommendation, recommender # generate_recommendation 사용
+import datetime
+
+# --- 로깅 설정 ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def migrate_diaries_with_recommendations():
+    """
+    기존의 모든 일기를 순회하며 'recommendation' 필드가 비어있는 경우,
+    새로운 추천을 생성하여 채워넣습니다.
+    """
+    app = create_app()
+    with app.app_context():
+        logging.info("데이터 마이그레이션을 시작합니다...")
+        
+        # 추천이 비어있는 모든 일기를 조회합니다.
+        diaries_to_update = Diary.query.filter((Diary.recommendation == None) | (Diary.recommendation == '')).all()
+        
+        if not diaries_to_update:
+            logging.info("업데이트할 일기가 없습니다. 모든 일기에 추천이 이미 존재합니다.")
+            return
+
+        logging.info(f"총 {len(diaries_to_update)}개의 일기를 업데이트합니다.")
+        
+        updated_count = 0
+        failed_count = 0
+
+        for diary in diaries_to_update:
+            try:
+                logging.info(f"ID: {diary.id} 일기 처리 중...")
+                
+                # 1. Gemini API를 통해 추천 생성 시도
+                recommendation_text = generate_recommendation(diary.content, diary.emotion)
+
+                # 2. 실패 시, Recommender 클래스로 대체
+                if recommendation_text is None:
+                    logging.warning(f"ID: {diary.id} - Gemini 추천 실패. Recommender 클래스로 대체합니다.")
+                    su_yoong_recs = recommender.recommend(diary.emotion, '수용')
+                    jeon_hwan_recs = recommender.recommend(diary.emotion, '전환')
+                    
+                    # diary_logic.js가 파싱할 수 있는 형식으로 만듭니다.
+                    recommendation_text = f"## [수용]\n"
+                    for rec in su_yoong_recs:
+                        recommendation_text += f"* {rec}\n"
+                    
+                    recommendation_text += f"\n## [전환]\n"
+                    for rec in jeon_hwan_recs:
+                        recommendation_text += f"* {rec}\n"
+                
+                # 3. 데이터베이스에 반영
+                diary.recommendation = recommendation_text
+                updated_count += 1
+                logging.info(f"ID: {diary.id} - 추천 생성 완료.")
+
+            except Exception as e:
+                failed_count += 1
+                logging.error(f"ID: {diary.id} 처리 중 오류 발생: {e}")
+
+        if updated_count > 0:
+            try:
+                db.session.commit()
+                logging.info(f"성공: {updated_count}개 일기의 추천 정보 업데이트 완료.")
+            except Exception as e:
+                db.session.rollback()
+                logging.error(f"데이터베이스 커밋 중 오류 발생: {e}")
+
+        if failed_count > 0:
+            logging.warning(f"실패: {failed_count}개 일기 처리 중 오류 발생.")
+        
+        logging.info("마이그레이션 완료.")
+
+if __name__ == '__main__':
+    migrate_diaries_with_recommendations()

scripts/newtrain.py

@@ -0,0 +1,282 @@
+#newtrain.py
+
+import os
+import pandas as pd
+import json
+import re
+import torch
+import numpy as np
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    Trainer,
+    TrainingArguments
+)
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+from sklearn.model_selection import train_test_split # 데이터 분리
+from sklearn.utils import class_weight
+from torch.nn import CrossEntropyLoss
+from typing import Dict, List, Tuple
+from dataclasses import dataclass
+import platform
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# --- Matplotlib 한글 폰트 설정 (로컬 PC용) ---
+try:
+    if platform.system() == 'Windows':
+        plt.rc('font', family='Malgun Gothic')
+    elif platform.system() == 'Darwin': # Mac OS
+        plt.rc('font', family='AppleGothic')
+    else: # Linux (코랩 등)
+        plt.rc('font', family='NanumBarunGothic')
+    plt.rcParams['axes.unicode_minus'] = False
+except:
+    print("한글 폰트 설정에 실패했습니다. 혼동 행렬의 라벨이 깨질 수 있습니다.")
+
+
+# --- 1. 설정부 ---
+@dataclass
+class TrainingConfig:
+    mode: str = "emotion" 
+    data_dir: str = "./data"
+    output_dir: str = "./results"
+    base_model_name: str = "klue/roberta-base"
+    eval_batch_size: int = 64
+    num_train_epochs: int = 10
+    learning_rate: float = 1e-5
+    train_batch_size: int = 16
+    weight_decay: float = 0.01
+    max_length: int = 128
+    warmup_ratio: float = 0.1
+    
+    def get_model_name(self) -> str:
+        return self.base_model_name
+        
+    def get_output_dir(self) -> str:
+        # v2 모델 저장 경로
+        return os.path.join(self.output_dir, 'emotion_model_v2_manual')
+
+# --- 2. 커스텀 클래스 및 함수 ---
+class EmotionDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+    def __getitem__(self, idx):
+        item = {key: val[idx].clone().detach() for key, val in self.encodings.items()}
+        item['labels'] = torch.tensor(self.labels[idx])
+        return item
+    def __len__(self):
+        return len(self.labels)
+
+class CustomTrainer(Trainer):
+    def __init__(self, *args, class_weights=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        if class_weights is not None:
+            self.loss_fct = CrossEntropyLoss(weight=class_weights)
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        labels = inputs.pop("labels")
+        outputs = model(**inputs)
+        logits = outputs.get("logits")
+        loss = self.loss_fct(logits.view(-1, self.model.config.num_labels), labels.view(-1))
+        return (loss, outputs) if return_outputs else loss
+
+def compute_metrics(pred):
+    labels = pred.label_ids
+    preds = pred.predictions.argmax(-1)
+    acc = accuracy_score(labels, preds)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='weighted', zero_division=0)
+    return {'accuracy': acc, 'f1': f1}
+
+def clean_text(text: str) -> str:
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', str(text))
+
+# --- 3. 데이터 로더 ([변경] Train/Val/Test 분리) ---
+def get_data(config: TrainingConfig) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    if config.mode == 'nsmc':
+      raise ValueError("이 스크립트는 'emotion' 모드 전용입니다.")
+
+    elif config.mode == 'emotion':
+        print("--- 감정 데이터 로딩 (Train/Val/Test 분리) ---")
+        
+        def load_and_map_labels(file_name):
+            def map_ecode_to_major_emotion(ecode):
+                try: code_num = int(ecode[1:])
+                except: return None
+                
+                if 10 <= code_num <= 19: return '분노'
+                elif 20 <= code_num <= 29: return '슬픔'
+                elif 30 <= code_num <= 39: return '불안'
+                elif 40 <= code_num <= 49: return '상처'
+                elif 50 <= code_num <= 59: return '당황'
+                elif 60 <= code_num <= 69: return '기쁨'
+                else: return None
+
+            with open(os.path.join(config.data_dir, file_name), 'r', encoding='utf-8') as f:
+                raw = json.load(f)
+            data = [{'text': " ".join(d['talk']['content'].values()), 'emotion': d['profile']['emotion']['type']} for d in raw]
+            df = pd.DataFrame(data)
+            df['major_emotion'] = df['emotion'].apply(map_ecode_to_major_emotion)
+            df.dropna(subset=['major_emotion'], inplace=True)
+            df['cleaned_text'] = df['text'].apply(clean_text)
+            return df
+        
+        # 1. Test Set 로드 (기존 validation-label.json 사용)
+        df_test = load_and_map_labels("test.json")
+        
+        # 2. Train Set 로드 (기존 training-label.json 사용)
+        df_train_full = load_and_map_labels("training-label.json")
+        
+        # 3. Train Set을 9:1로 분리 (신규 Train / 신규 Validation)
+        label_column_str = 'major_emotion'
+        
+        df_train, df_val = train_test_split(
+            df_train_full,
+            test_size=0.1,  # 10%를 Validation으로 사용
+            random_state=42, # 결과 재현을 위해 고정
+            stratify=df_train_full[label_column_str] # 클래스 비율을 유지하며 분리
+        )
+        
+        print(f"  총 원본 훈련 데이터: {len(df_train_full)}개")
+        print(f"  [신규] 훈련(Train)용: {len(df_train)}개 (90%)")
+        print(f"  [신규] 검증(Validation)용: {len(df_val)}개 (10%)")
+        print(f"  [최종] 테스트(Test)용: {len(df_test)}개 ")
+        
+        return df_train, df_val, df_test
+    else:
+        raise ValueError(f"지원하지 않는 모드입니다: {config.mode}")
+
+# --- 4. 메인 실행 함수 ---
+def run_training():
+    config = TrainingConfig()
+    df_train, df_val, df_test = get_data(config)
+    
+    text_column = 'cleaned_text'
+    label_column_str = 'major_emotion'
+    
+    # 2. 토크나이저 및 라벨 인코딩
+    tokenizer = AutoTokenizer.from_pretrained(config.get_model_name())
+    unique_labels = sorted(df_train[label_column_str].unique())
+    label_to_id = {label: i for i, label in enumerate(unique_labels)}
+    id_to_label = {i: label for label, i in label_to_id.items()}
+    
+    print("\n--- 생성된 라벨 순서 (0~5) ---")
+    print(unique_labels) # ['기쁨', '당황', '분노', '불안', '상처', '슬픔']
+    print("------------------------------")
+
+    df_train['label'] = df_train[label_column_str].map(label_to_id)
+    df_val['label'] = df_val[label_column_str].map(label_to_id)
+    df_test['label'] = df_test[label_column_str].map(label_to_id)
+
+    # 3. 데이터셋 생성 및 클래스 가중치 계산
+    train_encodings = tokenizer(list(df_train[text_column]), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    val_encodings = tokenizer(list(df_val[text_column]), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    
+    train_dataset = EmotionDataset(train_encodings, df_train['label'].tolist())
+    val_dataset = EmotionDataset(val_encodings, df_val['label'].tolist())
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"\nUsing device: {device}")
+    # 클래스 가중치 계산 
+    manual_weights_list = [6.00, 4.50, 0.85, 1.80, 1.80, 0.92] 
+    class_weights = torch.tensor(manual_weights_list, dtype=torch.float).to(device)
+    
+    print(f"--- 수동 적용된 클래스 가중치 ---")
+    print(f"{class_weights.tolist()}")
+    print(f"---------------------------------")
+
+
+    # 4. 모델 로딩
+    model = AutoModelForSequenceClassification.from_pretrained(
+        config.get_model_name(),
+        num_labels=len(unique_labels),
+        id2label=id_to_label,
+        label2id=label_to_id,
+        ignore_mismatched_sizes=True 
+    ).to(device)
+
+    # 5. 훈련 실행
+    training_args = TrainingArguments(
+        output_dir=config.get_output_dir(),
+        num_train_epochs=config.num_train_epochs,
+        per_device_train_batch_size=config.train_batch_size,
+        per_device_eval_batch_size=config.eval_batch_size,
+        learning_rate=config.learning_rate,
+        weight_decay=config.weight_decay,
+        warmup_ratio=config.warmup_ratio,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        lr_scheduler_type="cosine",  
+        report_to="none"
+    )
+
+    trainer = CustomTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,      
+        compute_metrics=compute_metrics,
+        class_weights=class_weights
+    )
+    
+    print(f"\n '[신규 분리 데이터]'로 모델 훈련을 시작합니다...")
+    trainer.train()
+    print("\n 모델 훈련 완료!")
+
+    output_dir = config.get_output_dir()
+    trainer.save_model(output_dir)
+    tokenizer.save_pretrained(output_dir)
+    print(f"최종 모델과 토크나이저가 {output_dir} 경로에 저장되었습니다.")
+    
+    # 훈련 중 사용한 검증 데이터(10%)에 대한 평가 결과
+    print("\n--- 신규 Validation Set(10%) 평가 결과 (참고용) ---")
+    results = trainer.evaluate() # 기본값 (eval_dataset)
+    print(results)
+
+    # --- 최종 Test Set으로 '진짜 성능' 평가 ---
+    print("\n" + "="*50)
+    print("--- 최종 Test Set으로 '진짜 성능' 평가 시작 ---")
+    print("="*50)
+    
+    # Test Set을 위한 데이터셋 생성
+    test_encodings = tokenizer(list(df_test[text_column]), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    test_dataset = EmotionDataset(test_encodings, df_test['label'].tolist())
+
+    # trainer.predict()를 사용하여 Test Set에 대한 예측 수행
+    test_predictions = trainer.predict(test_dataset)
+    
+    # compute_metrics 함수를 ���사용하여 '진짜 성능' 계산
+    final_metrics = compute_metrics(test_predictions)
+    
+    print(f"*** 최종 Test Set '진짜' 성능 결과 ***")
+    print(f"  - 최종 Accuracy: {final_metrics['accuracy']:.4f}")
+    print(f"  - 최종 F1-Score (Weighted): {final_metrics['f1']:.4f}")
+    print("="*50)
+
+    results_path = os.path.join(output_dir, "final_test_results.json")
+    with open(results_path, "w", encoding='utf-8') as f:
+        json.dump(final_metrics, f, indent=4, ensure_ascii=False)
+    print(f"최종 테스트 결과가 {results_path}에 저장되었습니다.")
+
+    # --- Test Set 기준 혼동 행렬 생성 ---
+    print("\n--- Test Set 기준 혼동 행렬 생성 ---")
+    y_pred = test_predictions.predictions.argmax(-1)
+    y_true = test_predictions.label_ids
+
+    labels = [id_to_label[i] for i in sorted(id_to_label.keys())]
+    cm = confusion_matrix(y_true, y_pred, labels=[label_to_id[l] for l in labels])
+    
+    plt.figure(figsize=(10, 8))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
+    plt.xlabel('예측 라벨 (Predicted Label)')
+    plt.ylabel('실제 라벨 (True Label)')
+    plt.title('Test Set Confusion Matrix')
+    
+    cm_path = os.path.join(output_dir, "final_test_confusion_matrix.png")
+    plt.savefig(cm_path)
+    print(f"최종 혼동 행렬이 {cm_path}에 저장되었습니다.")
+
+if __name__ == "__main__":
+    run_training()

scripts/train_final.py

@@ -0,0 +1,331 @@
+# 파일 이름: train_final.py
+
+import os
+import pandas as pd
+import json
+import re
+import torch
+import numpy as np
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    Trainer, 
+    TrainingArguments
+)
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+from sklearn.model_selection import train_test_split 
+from sklearn.utils import resample 
+from typing import Dict, List, Tuple
+from dataclasses import dataclass
+import platform
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# --- Matplotlib 한글 폰트 설정 ---
+try:
+    if platform.system() == 'Windows':
+        plt.rc('font', family='Malgun Gothic')
+    elif platform.system() == 'Darwin': # Mac OS
+        plt.rc('font', family='AppleGothic')
+    else: # Linux (코랩 등)
+        plt.rc('font', family='NanumBarunGothic')
+    plt.rcParams['axes.unicode_minus'] = False
+except Exception as e:
+    print(f"한글 폰트 설정 경고: {e}. 혼동 행렬의 라벨이 깨질 수 있습니다.")
+
+# --- 1. 설정부 ---
+@dataclass
+class TrainingConfig:
+    mode: str = "emotion" 
+    data_dir: str = "./data"
+    output_dir: str = "./results1024"
+    base_model_name: str = "klue/roberta-base"
+    eval_batch_size: int = 64
+    num_train_epochs: int = 3 
+    learning_rate: float = 2e-5
+    train_batch_size: int = 16
+    weight_decay: float = 0.01
+    max_length: int = 128
+    warmup_ratio: float = 0.1
+    
+    def get_model_name(self) -> str:
+        if self.mode == 'emotion':
+            if not os.path.exists(self.base_model_name):
+                print(f"경고: 1차 학습된 NSMC 모델을 찾을 수 없습니다 ({self.base_model_name})")
+                print("기본 'klue/roberta-base' 모델로 대신 학습을 시도합니다.")
+                return "klue/roberta-base"
+            print(f"1차 학습된 모델 로드: {self.base_model_name}")
+            return self.base_model_name
+        return "klue/roberta-base"
+        
+    def get_output_dir(self) -> str:
+        # 모델 저장 경로 수정 
+        return os.path.join(self.output_dir, 'emotion_model_6class_oversampled')
+
+# --- 2. 커스텀 클래스 및 함수 ---
+class EmotionDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+    def __getitem__(self, idx):
+        item = {key: val[idx].clone().detach() for key, val in self.encodings.items()}
+        item['labels'] = torch.tensor(self.labels[idx])
+        return item
+    def __len__(self):
+        return len(self.labels)
+
+def compute_metrics(pred):
+    labels = pred.label_ids
+    preds = pred.predictions.argmax(-1)
+    acc = accuracy_score(labels, preds)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='weighted', zero_division=0)
+    return {'accuracy': acc, 'f1': f1}
+
+def clean_text(text: str) -> str:
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', str(text))
+
+# --- 3. 데이터 로더 ---
+
+def map_ecode_to_6class(e_code_str):
+    """E코드("E18")를 6-Class("분노")로 매핑하는 함수"""
+    if not isinstance(e_code_str, str) or not e_code_str.startswith('E'): return None
+    try: code_num = int(e_code_str[1:]) 
+    except (ValueError, TypeError): return None
+    
+    if 10 <= code_num <= 19: return '분노'
+    elif 20 <= code_num <= 29: return '슬픔'
+    elif 30 <= code_num <= 39: return '불안'
+    elif 40 <= code_num <= 49: return '상처'
+    elif 50 <= code_num <= 59: return '당황'
+    elif 60 <= code_num <= 69: return '기쁨'
+    else: return None
+
+def load_and_process(text_file, label_file, data_dir):
+    """Excel(텍스트)과 JSON(라벨)을 병합하고 전처리하는 헬퍼 함수"""
+    text_path = os.path.join(data_dir, text_file)
+    label_path = os.path.join(data_dir, label_file)
+    try:
+        df_text = pd.read_excel(text_path, header=None)
+        with open(label_path, 'r', encoding='utf-8') as f:
+            labels_raw = json.load(f)
+    except FileNotFoundError as e:
+        print(f"오류: 필수 파일을 찾을 수 없습니다: {e}")
+        return pd.DataFrame()
+    
+    e_codes = []
+    for dialogue in labels_raw:
+        try: e_codes.append(dialogue['profile']['emotion']['type']) # "E18"
+        except KeyError: e_codes.append(None)
+    
+    if len(df_text) != len(e_codes):
+        min_len = min(len(df_text), len(e_codes))
+        print(f"경고: {text_file}과 {label_file} 줄 수 불일치. {min_len}개로 축소합니다.")
+        df_text = df_text.iloc[:min_len]
+        e_codes = e_codes[:min_len]
+        
+    df_labels = pd.DataFrame({'e_code': e_codes})
+    df_combined = pd.concat([df_text, df_labels], axis=1)
+    
+    dialogue_cols = [8, 9, 10, 11]
+    for col in dialogue_cols:
+        df_combined[col] = df_combined[col].astype(str).fillna('')
+    df_combined['text'] = df_combined[dialogue_cols].apply(lambda row: ' '.join(row), axis=1)
+
+    df_combined['cleaned_text'] = df_combined['text'].apply(clean_text)
+    
+    df_combined['major_emotion'] = df_combined['e_code'].apply(map_ecode_to_6class)
+    
+    df_combined.dropna(subset=['major_emotion', 'cleaned_text'], inplace=True)
+    df_combined = df_combined[df_combined['cleaned_text'].str.strip() != '']
+    
+    return df_combined
+
+def get_data(config: TrainingConfig) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """
+    Train/Val/Test 3-Set을 로드하고, Train Set에 Oversampling을 적용
+    """
+    if config.mode != 'emotion':
+        print("이 스크립트는 'emotion' 모드 전용입니다.")
+        return pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
+
+    print("--- 감정 데이터 로딩 (Train/Validation/Test) ---")
+    
+    df_full_train = load_and_process("training-origin.xlsx", "training-label.json", config.data_dir)
+    df_test = load_and_process("validation-origin.xlsx", "test.json", config.data_dir)
+    
+    if df_full_train.empty or df_test.empty:
+        print("오류: 데이터 로딩 실패.")
+        return pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
+
+    print(f"Full Train data loaded: {len(df_full_train)} rows")
+    print(f"Test data loaded: {len(df_test)} rows")
+
+    print("Splitting Full Train into New Train (90%) and New Validation (10%)...")
+    df_train, df_val = train_test_split(
+        df_full_train,
+        test_size=0.1,  
+        random_state=42, 
+        stratify=df_full_train['major_emotion'] 
+    )
+    
+    print("\n--- [Oversampling] New Train 6-Class (원본 분포) ---")
+    print(df_train['major_emotion'].value_counts())
+
+    # --- [오버샘플링 시작] ---
+    print("\n--- '기쁨' 클래스 오버샘플링 적용 중 ---")
+    
+    # 1. '기쁨'과 나머지 분리
+    df_train_joy = df_train[df_train['major_emotion'] == '기쁨']
+    df_train_others = df_train[df_train['major_emotion'] != '기쁨']
+    
+    # 2. '기쁨'을 제외한 5개 클래스의 평균 개수 계산
+    target_count = int(df_train_others['major_emotion'].value_counts().mean())
+    print(f"  '기쁨' 원본: {len(df_train_joy)}개")
+    print(f"  다른 클래스 평균(타겟): {target_count}개")
+    
+    # 3. '기쁨'을 타겟 개수만큼 복제 (with replacement)
+    df_joy_oversampled = resample(
+        df_train_joy,
+        replace=True,
+        n_samples=target_count, # 타겟 개수
+        random_state=42
+    )
+    
+    # 4. 나머지 데이터와 복제된 '기쁨' 데이터를 다시 합침
+    df_train = pd.concat([df_train_others, df_joy_oversampled])
+    
+    # 5. 데이터셋을 다시 섞어줌
+    df_train = df_train.sample(frac=1, random_state=42).reset_index(drop=True)
+    
+    print("\n--- [Oversampling] New Train 6-Class (최종 분포) ---")
+    print(df_train['major_emotion'].value_counts())
+    # --- [오버샘플링 끝] ---
+    
+    print(f"\nNew Train set (Oversampled) size: {len(df_train)}")
+    print(f"New Validation set (Original) size: {len(df_val)}")
+    
+    return df_train, df_val, df_test
+
+# --- 4. 메인 실행 함수 ---
+def run_training():
+    config = TrainingConfig()
+    
+    df_train, df_val, df_test = get_data(config)
+    
+    if df_train.empty or df_val.empty or df_test.empty:
+        print("\n오류: 데이터가 비어있어 훈련을 중단합니다.")
+        return
+
+    text_column = 'cleaned_text'
+    label_column_str = 'major_emotion' 
+    
+    model_name_to_load = config.get_model_name()
+    tokenizer = AutoTokenizer.from_pretrained(model_name_to_load)
+
+    unique_labels = sorted(df_train[label_column_str].unique())
+    label_to_id = {label: i for i, label in enumerate(unique_labels)}
+    id_to_label = {i: label for label, i in label_to_id.items()}
+    
+    print(f"\n라벨 인코딩 맵 (6-Class): {label_to_id}")
+    
+    df_train['label'] = df_train[label_column_str].map(label_to_id)
+    df_val['label'] = df_val[label_column_str].map(label_to_id) 
+    df_test['label'] = df_test[label_column_str].map(label_to_id)
+
+    print("데이터셋 토크나이징 중...")
+    train_encodings = tokenizer(list(df_train[text_column]), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    val_encodings = tokenizer(list(df_val[text_column]), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    test_encodings = tokenizer(list(df_test[text_column]), max_length=config.max_length, padding=True, truncation=True, return_tensors="pt")
+    
+    train_dataset = EmotionDataset(train_encodings, df_train['label'].tolist())
+    val_dataset = EmotionDataset(val_encodings, df_val['label'].tolist())
+    test_dataset = EmotionDataset(test_encodings, df_test['label'].tolist())
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"\nUsing device: {device}")
+    
+    print("모델 로딩 중...")
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_name_to_load,
+        num_labels=len(unique_labels),
+        id2label=id_to_label,
+        label2id=label_to_id,
+        ignore_mismatched_sizes=True 
+    ).to(device)
+
+    output_dir = config.get_output_dir()
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=config.num_train_epochs,
+        per_device_train_batch_size=config.train_batch_size,
+        per_device_eval_batch_size=config.eval_batch_size,
+        learning_rate=config.learning_rate,
+        weight_decay=config.weight_decay,
+        warmup_ratio=config.warmup_ratio,
+        eval_strategy="epoch",      
+        save_strategy="epoch",
+        load_best_model_at_end=True,     
+        metric_for_best_model="accuracy", 
+        report_to="none"
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,      
+        compute_metrics=compute_metrics
+    )
+    
+    print(f"\n 6-Class (Oversampled) 모델 훈련을 시작합니다...")
+    trainer.train()
+    print("\n 모델 훈련 완료!")
+
+    final_model_path = os.path.join(output_dir, "best_model")
+    trainer.save_model(final_model_path)
+    tokenizer.save_pretrained(final_model_path)
+    print(f"최종 모델(Best)과 토크나이저가 {final_model_path} 경로에 저장되었습니다.")
+    
+    print("\n--- (1) Validation Set 평가 (모의고사) ---")
+    val_results = trainer.evaluate(eval_dataset=val_dataset)
+    print(f"최종 Validation 평가 결과: {val_results}")
+    
+    results_path = os.path.join(output_dir, "validation_evaluation_results.json")
+    with open(results_path, "w", encoding='utf-8') as f:
+        json.dump(val_results, f, indent=4, ensure_ascii=False)
+    print(f"Validation 평가 결과가 {results_path}에 저장되었습니다.")
+
+    print("\n--- (2) Test Set 최종 평가 (수능) ---")
+    test_predictions = trainer.predict(test_dataset)
+    test_metrics = test_predictions.metrics
+    print(f"최종 Test 평가 결과: {test_metrics}")
+
+    results_path = os.path.join(output_dir, "TEST_evaluation_results.json")
+    with open(results_path, "w", encoding='utf-8') as f:
+        json.dump(test_metrics, f, indent=4, ensure_ascii=False)
+    print(f"*** 최종 Test 평가 결과가 {results_path}에 저장되었습니다. ***")
+
+    print("\n--- 혼동 행렬 생성 (Test Set) ---")
+    try:
+        y_pred = test_predictions.predictions.argmax(-1)
+        y_true = test_predictions.label_ids
+
+        labels = [id_to_label[i] for i in sorted(id_to_label.keys())]
+        cm = confusion_matrix(y_true, y_pred, labels=[label_to_id[l] for l in labels])
+        
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
+        plt.xlabel('예측 라벨 (Predicted Label)')
+        plt.ylabel('실제 라벨 (True Label)')
+        plt.title('Confusion Matrix (TEST Set - 6-Class Oversampled)')
+        
+        cm_path = os.path.join(output_dir, "TEST_confusion_matrix.png")
+        plt.savefig(cm_path)
+        print(f"Test Set 혼동 행렬이 {cm_path}에 저장되었습니다.")
+    except Exception as e:
+        print(f"\n!!! 오류: 혼동 행렬 생성 실패: {e} !!!")
+        print("matplotlib, seaborn 라이브러리가 설치되었는지 확인하세요.")
+
+if __name__ == "__main__":
+    print("--- 6-Class (Oversampling) 감정 분류 모델 학습 시작 ---")
+    run_training()

server.log

@@ -0,0 +1,256 @@
+ * Serving Flask app 'src'
+ * Debug mode: off
+WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on http://127.0.0.1:5000
+Press CTRL+C to quit
+127.0.0.1 - - [20/Oct/2025 01:09:21] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:21] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:09:35] "GET /auth/logout HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:35] "GET /auth/logout HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:09:35] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:35] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:09:38] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:38] "GET /auth/signup HTTP/1.1" 200 -
+WARNING:root:\u2705 DB ���� ����: ����� '��'�� �߰��Ǿ����ϴ�.
+127.0.0.1 - - [20/Oct/2025 01:09:43] "POST /auth/signup HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:43] "POST /auth/signup HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:09:43] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:43] "GET /auth/login HTTP/1.1" 200 -
+WARNING:root:--- �α��� �õ�: ����ڸ� '��' ---
+127.0.0.1 - - [20/Oct/2025 01:09:46] "POST /auth/login HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:46] "POST /auth/login HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:09:46] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:46] "GET / HTTP/1.1" 200 -
+Device set to use cpu
+127.0.0.1 - - [20/Oct/2025 01:09:52] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:52] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:09:53] "POST /diary/save HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:53] "POST /diary/save HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:09:54] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:54] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:09:55] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:09:55] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:10:11] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:10:11] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:10:16] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:10:16] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:10:16] "POST /diary/save HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:10:16] "POST /diary/save HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:10:17] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:10:17] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:10:18] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:10:18] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:01] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:01] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:01] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:01] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:04] "GET /auth/logout HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:04] "GET /auth/logout HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:34:04] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:04] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:04] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:04] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 01:34:06] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:06] "GET /auth/signup HTTP/1.1" 200 -
+WARNING:root:\u2705 DB ���� ����: ����� '��'�� �߰��Ǿ����ϴ�.
+127.0.0.1 - - [20/Oct/2025 01:34:09] "POST /auth/signup HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:09] "POST /auth/signup HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:34:09] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:09] "GET /auth/login HTTP/1.1" 200 -
+WARNING:root:--- �α��� �õ�: ����ڸ� '��' ---
+127.0.0.1 - - [20/Oct/2025 01:34:11] "POST /auth/login HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:11] "POST /auth/login HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:34:11] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:11] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:16] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:16] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:18] "POST /diary/save HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:18] "POST /diary/save HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:20] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:20] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:34:20] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:34:20] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:36:40] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:36:40] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:36:44] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:36:44] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:36:45] "POST /diary/save HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:36:45] "POST /diary/save HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:36:46] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:36:46] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:36:46] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:36:46] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:38:54] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:38:54] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:38:58] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:38:58] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:39:03] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:39:03] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:39:06] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:39:06] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:39:10] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:39:10] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:39:13] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:39:13] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:56:50] "GET /auth/logout HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:50] "GET /auth/logout HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:56:50] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:50] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:56:52] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:52] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:56:53] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:53] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 01:56:55] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:55] "GET /auth/signup HTTP/1.1" 200 -
+WARNING:root:\u2705 DB ���� ����: ����� '��'�� �߰��Ǿ����ϴ�.
+127.0.0.1 - - [20/Oct/2025 01:56:58] "POST /auth/signup HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:58] "POST /auth/signup HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:56:58] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:58] "GET /auth/login HTTP/1.1" 200 -
+WARNING:root:--- �α��� �õ�: ����ڸ� '��' ---
+127.0.0.1 - - [20/Oct/2025 01:56:59] "POST /auth/login HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:59] "POST /auth/login HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 01:56:59] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:56:59] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:57:04] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:57:04] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:57:04] "POST /diary/save HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:57:04] "POST /diary/save HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:57:06] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:57:06] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:57:06] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:57:06] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 01:57:19] "GET /api/diaries?year=2025&month=8 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 01:57:19] "GET /api/diaries?year=2025&month=8 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:04:20] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:04:20] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:04:25] "GET /auth/logout HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:04:25] "GET /auth/logout HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:04:25] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:04:25] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:04:27] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:04:27] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:04:27] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:04:27] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:05:13] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:13] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:14] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:14] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:05:15] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:15] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:15] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:15] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:05:15] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:15] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:16] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:16] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:16] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:16] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:16] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:16] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:05:17] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:17] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:17] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:17] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:05:18] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:18] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:05:19] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:05:19] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:20] "GET / HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:20] "GET / HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:20:20] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:20] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:21] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:21] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:22] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:22] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:20:22] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:22] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:22] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:22] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /favicon.ico HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:23] "GET /favicon.ico HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:20:24] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:24] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:24] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:24] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:28] "GET / HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:28] "GET / HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:20:28] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:28] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:30] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:30] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:20:31] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:31] "GET /auth/login HTTP/1.1" 200 -
+WARNING:root:--- �α��� �õ�: ����ڸ� '��' ---
+127.0.0.1 - - [20/Oct/2025 02:20:37] "POST /auth/login HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:37] "POST /auth/login HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:20:37] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:20:37] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:23] "GET / HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:23] "GET / HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:22:23] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:23] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:28] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:28] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:29] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:29] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:29] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:29] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:31] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:31] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:32] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:32] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:38] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:38] "GET /auth/login HTTP/1.1" 200 -
+WARNING:root:--- �α��� �õ�: ����ڸ� '��' ---
+127.0.0.1 - - [20/Oct/2025 02:22:41] "POST /auth/login HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:41] "POST /auth/login HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:22:41] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:41] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:48] "POST /api/predict HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:48] "POST /api/predict HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:48] "POST /diary/save HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:48] "POST /diary/save HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:50] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:50] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:22:50] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:22:50] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:00] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:00] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:23:26] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:26] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:26] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:26] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:23:26] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:26] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:33] "GET /my_diary HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:33] "GET /my_diary HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:33] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:33] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:23:33] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:33] "GET /api/diaries?year=2025&month=9 HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:35] "GET / HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:35] "GET / HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:35] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:35] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:23:37] "GET /auth/logout HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:37] "GET /auth/logout HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:23:37] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:37] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:23:37] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:23:37] "GET /.well-known/appspecific/com.chrome.devtools.json HTTP/1.1" 404 -
+127.0.0.1 - - [20/Oct/2025 02:26:18] "GET / HTTP/1.1" 302 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:26:18] "GET / HTTP/1.1" 302 -
+127.0.0.1 - - [20/Oct/2025 02:26:18] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:26:18] "GET /auth/login HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:26:22] "GET /auth/signup HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:26:22] "GET /auth/signup HTTP/1.1" 200 -
+127.0.0.1 - - [20/Oct/2025 02:26:23] "GET /auth/login HTTP/1.1" 200 -
+INFO:werkzeug:127.0.0.1 - - [20/Oct/2025 02:26:23] "GET /auth/login HTTP/1.1" 200 -

src/__init__.py

@@ -0,0 +1,67 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_login import LoginManager
+import os
+
+db = SQLAlchemy()
+login_manager = LoginManager()
+login_manager.login_view = 'auth.login' 
+
+def create_app():
+    app = Flask(__name__, static_folder='templates/static')
+    
+    # 1. 설정
+    app.config['SECRET_KEY'] = 'a-very-long-and-unique-secret-key-for-this-app'
+    app.config['SESSION_COOKIE_SAMESITE'] = 'None'
+    app.config['SESSION_COOKIE_SECURE'] = True
+    
+    db_uri = os.environ.get('DATABASE_URL')
+    if not db_uri:
+        db_uri = "sqlite:///emotion.db"
+
+    if db_uri and db_uri.startswith("postgres://"):
+        db_uri = db_uri.replace("postgres://", "postgresql://", 1)
+    
+    app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
+    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+    app.config['TEMPLATES_AUTO_RELOAD'] = True
+
+    # SQLAlchemy 엔진 옵션 설정 (pgbouncer Session 모드 호환)
+    app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
+        "pool_size": 15,  # pgbouncer의 pool_size와 일치시키거나 더 작게 설정
+        "max_overflow": 5, # pool_size 초과 시 임시로 열 수 있는 연결 수
+        "pool_recycle": 3600, # 1시간마다 연결 재활용 (오래된 연결 방지)
+        "pool_pre_ping": True, # 연결 사용 전 유효성 검사
+        "pool_timeout": 30, # 연결 풀에서 연결을 기다리는 최대 시간 (초)
+        # pgbouncer Session 모드에서는 'rollback'이 기본값이므로 명시적으로 설정하지 않아도 됨
+        # "pool_reset_on_return": 'rollback' 
+    }
+
+    # 로깅 설정
+    import logging
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+    
+    # 2. DB 초기화 및 테이블 생성
+    db.init_app(app)
+    with app.app_context():
+        from . import models
+        db.create_all()
+
+    @app.teardown_appcontext
+    def shutdown_session(exception=None):
+        db.session.remove()
+
+   # 3. AI 모델 로딩
+    from .emotion_engine import load_emotion_classifier
+    # 앱 컨텍스트 안에서 모델을 로드하고 app 객체에 저장합니다.
+    with app.app_context():
+        app.emotion_classifier = load_emotion_classifier()
+        
+
+
+    # 5. 블루프린트 등록
+    from . import main, auth
+    app.register_blueprint(main.bp)
+    app.register_blueprint(auth.bp)
+
+    return app

src/auth.py

@@ -0,0 +1,78 @@
+# src/ auth.py
+# 기존 app.py에서 auth와 관련해서 분리
+# 로그인이나 회원가입 인증 관련한 스크립트
+
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash
+import logging
+from werkzeug.security import generate_password_hash, check_password_hash
+from . import db
+from .models import User
+
+bp = Blueprint('auth', __name__, url_prefix='/auth')
+
+# 로그인 파트
+@bp.route('/login', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        username = request.form['username']
+        password = request.form['password']
+        logging.warning(f"--- 로그인 시도: 사용자명 '{username}' ---")
+
+        # 데이터베이스에서 사용자 정보 조회
+        user = User.query.filter_by(username=username).first()
+
+        if not user or not user.check_password(password):
+            flash('로그인 정보가 올바르지 않습니다.')
+            # 로그인 실패 시 다시 로그인 화면(앞면)
+            return render_template('auth_combined.html')
+        
+        # 로그인 성공
+        session.clear()
+        session['user_id'] = user.id
+        session['username'] = user.username
+        return redirect(url_for('main.home'))
+
+    return render_template('auth_combined.html')
+
+# 회원가입 파트
+@bp.route('/signup', methods=['GET', 'POST'])
+def signup():
+    try:
+        if request.method == 'POST':
+            username = request.form['username']
+            password = request.form['password']
+            
+            # 1. 중복 사용자 확인
+            if User.query.filter_by(username=username).first():
+                 flash('이미 존재하는 사용자입니다.')
+                 # [핵심] 이미 존재하면 카드가 뒤집힌 상태(회원가입 화면)를 유지하기 위해 mode='signup'을 전달
+                 return redirect(url_for('auth.login', mode='signup'))
+
+            # 2. 새 사용자 생성
+            new_user = User(username=username)
+            new_user.set_password(password)
+            
+            db.session.add(new_user)
+            db.session.commit()
+            logging.warning("✅ DB 저장 성공: 사용자 '{}'가 추가되었습니다.".format(username))
+            
+            # 3. 가입 성공 시 로그인 화면(앞면)으로 이동
+            flash('회원가입이 완료되었습니다. 로그인해주세요.')
+            return redirect(url_for('auth.login'))
+
+    except Exception as e:
+        db.session.rollback()
+        logging.exception("🔥🔥🔥 signup 함수에서 DB 오류 발생! 🔥🔥🔥")
+        return "Internal Server Error", 500
+
+    
+    return render_template('auth_combined.html')
+
+# 로그아웃 part
+@bp.route('/logout')
+def logout():
+
+    # 세션에서 사용자 정보 제거
+    session.clear()
+    # 로그아웃 후 로그인 페이지로 이동
+    return redirect(url_for('auth.login'))

src/emotion_engine.py

@@ -0,0 +1,56 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+import os
+import logging
+
+# 모델을 저장할 전역 변수
+_classifier = None
+
+def load_emotion_classifier():
+    global _classifier
+    # 모델이 이미 로드되었다면, 즉시 반환
+    if _classifier is not None:
+        return _classifier
+
+    # 모델이 로드되지 않았다면, 로드 시작
+    MODEL_ID = "taehoon222/korean-emotion-classifier-final"
+
+    logging.info(f"Hugging Face Hub 모델 '{MODEL_ID}'에서 모델을 불러옵니다...")
+    try:
+        logging.info("토크나이저 로딩 중...")
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+        logging.info("모델 로딩 중...")
+        model = AutoModelForSequenceClassification.from_pretrained(MODEL_ID)
+        logging.info("Hugging Face Hub 모델 로딩 성공!")
+    except Exception as e:
+        logging.error(f"모델 로딩 중 오류: {e}")
+        return None
+    
+    device = 0 if torch.cuda.is_available() else -1
+    if device == 0:
+        logging.info("Device set to use cuda (GPU)")
+    else:
+        logging.info("Device set to use cpu")
+    
+    # 로드된 모델을 전역 변수에 저장
+    _classifier = pipeline("text-classification", model=model, tokenizer=tokenizer, device=device)
+    return _classifier
+
+def predict_emotion(text, top_k=3):
+    logging.info(f"predict_emotion 함수 호출됨. 텍스트 길이: {len(text) if text else 0}, top_k={top_k}")
+    classifier = load_emotion_classifier()
+    if not text or not text.strip():
+        logging.warning("분석할 텍스트가 비어있거나 공백입니다.")
+        return []
+    if classifier is None:
+        logging.error("감정 분석 엔진이 준비되지 않았습니다.")
+        return []
+    
+    try:
+        logging.info(f"분류기 실행 중... 텍스트: {text[:50]}...") 
+        results = classifier(text, top_k=top_k)
+        logging.info(f"분류 결과 (Top {top_k}): {results}")
+        return results
+    except Exception as e:
+        logging.error(f"감정 분류 중 오류 발생: {e}")
+        return []

src/main.py

@@ -0,0 +1,373 @@
+from flask import Blueprint, render_template, session, redirect, url_for, jsonify, request, current_app
+from sqlalchemy import extract, String # String 추가
+import datetime
+import time
+from . import db
+from .models import Diary, User
+from .emotion_engine import predict_emotion
+from .recommender import Recommender
+import logging
+import os
+import google.generativeai as genai
+
+bp = Blueprint('main', __name__)
+recommender = Recommender()
+
+# --- Gemini API 설정 ---
+try:
+    api_key = os.environ.get('GEMINI_API_KEY')
+    if not api_key:
+        logging.warning("🔥🔥🔥 GEMINI_API_KEY 환경 변수가 설정되지 않았습니다. 🔥🔥🔥")
+    genai.configure(api_key=api_key)
+except Exception as e:
+    logging.error(f"🔥🔥🔥 Gemini API 설정 중 오류 발생: {e} 🔥🔥🔥")
+
+
+# 감정별 이모지 맵
+emotion_emoji_map = {
+    '분노': '😠', '불안': '😟', '슬픔': '😢',
+    '당황': '😮', '기쁨': '😄', '상처': '💔',
+}
+
+default_recommendations = {
+    '분노': '화가 날 때는 신나는 음악을 듣거나, 가벼운 코미디 영화를 보며 기분을 전환해 보세요.',
+    '불안': '불안할 때는 차분한 클래식 음악을 듣거나, 따뜻한 차를 마시며 명상을 해보는 건 어떨까요?',
+    '슬픔': '슬플 때는 위로가 되는 영화나 책을 보며 감정을 충분히 느껴보는 것도 좋아요. 혹은 친구와 대화를 나눠보세요.',
+    '당황': '당황스러울 때는 잠시 숨을 고르고, 좋아하는 음악을 들으며 마음을 진정시켜 보세요.',
+    '기쁨': '기쁠 때는 신나는 댄스 음악과 함께 춤을 추거나, 친구들과 만나 즐거움을 나눠보세요!',
+    '상처': '마음의 상처를 받았을 때는, 위로가 되는 음악을 듣거나, 조용한 곳에서 책을 읽으며 마음을 달래보세요.'
+}
+
+def generate_recommendation(user_diary, predicted_emotion):
+    """
+    주어진 일기 내용과 감정을 바탕으로 Gemini API를 사용하여 문화생활 추천을 생성합니다.
+    """
+    start_time = time.time()
+    logging.info("Gemini API 호출 시작...")
+    try:
+        model = genai.GenerativeModel('gemini-flash-latest')
+        prompt = f"""
+        사용자의 일기 내용과 감정을 바탕으로 문화생활을 추천해줘.
+        사용자는 현재 '{predicted_emotion}' 감정을 느끼고 있어.
+
+        일기 내용:
+        ---
+        {user_diary}
+        ---
+
+        아래 두 가지 시나리오에 맞춰 영화, 음악, 도서만 추천해줘.
+        각 추천 항목은 "종류: 추천 콘텐츠 제목 (아티스트/감독/작가 등)" 형식으로 작성하고, 간단한 추천 이유를 덧붙여줘.
+        결과는 Markdown 형식으로 보기 좋게 정리해줘.
+        
+        ## [수용]
+        현재 감정을 더 깊이 느끼거나 위로받고 싶을 때.
+
+        ## [전환]
+        현재 감정에서 벗어나 새로운 활력을 얻고 싶을 때.
+        """
+        
+        response = model.generate_content(prompt)
+        end_time = time.time()
+        logging.info(f"Gemini API 호출 완료. 소요 시간: {end_time - start_time:.2f}초")
+        return response.text
+    except Exception as e:
+        logging.error(f"🔥🔥🔥 Gemini API 호출 중 오류 발생: {e} 🔥🔥🔥")
+        return default_recommendations.get(predicted_emotion, "오늘은 좋아하는 음악을 들으며 편안한 하루를 보내는 건 어떠세요?")
+
+
+@bp.route("/")
+def home():
+    if 'user_id' not in session:
+        return redirect(url_for('auth.login'))
+    logged_in = 'user_id' in session
+    display_name = None
+    if logged_in:
+        user_id = session.get('user_id')
+        user = User.query.get(user_id)
+        if user:
+            display_name = user.nickname if user.nickname else user.username
+        else:
+            display_name = session.get('username') # Fallback if user not found
+    logging.info(f"메인 페이지 접속: 로그인 상태: {logged_in}, 사용자: {display_name}")
+    return render_template("main.html", logged_in=logged_in, display_name=display_name)
+
+
+@bp.route("/api/predict", methods=["POST"])
+def api_predict():
+    if 'user_id' not in session:
+        return jsonify({"error": "로그인이 필요합니다."}), 401
+        
+    user_diary = request.json.get("diary")
+    if not user_diary:
+        return jsonify({"error": "일기 내용이 없습니다."}), 400
+
+    try:
+        # 1. Predict top 3 emotions
+        emotion_results = predict_emotion(user_diary, top_k=3)
+
+        if not emotion_results:
+            logging.error("[/api/predict] 감정 분석 결과가 없습니다.")
+            return jsonify({"error": "감정을 분석할 수 없습니다."}), 500
+
+        # 2. Process results
+        top_emotion_data = emotion_results[0]
+        top_emotion_label = top_emotion_data['label']
+        top_emotion_score = top_emotion_data['score']
+
+        # 3. Create candidates list
+        candidates = []
+        for result in emotion_results:
+            emotion_label = result['label']
+            candidates.append({
+                'emotion': emotion_label,
+                'score': result['score'],
+                'emoji': emotion_emoji_map.get(emotion_label, '🤔')
+            })
+
+        # 4. Generate recommendation ONLY for the top emotion initially
+        recommendation_text = generate_recommendation(user_diary, top_emotion_label)
+
+        # 5. Return the new structure
+        # Note: Diary is NOT saved here. It will be saved via a separate '/diary/save' call later.
+        return jsonify({
+            "top_emotion": top_emotion_label,
+            "top_score": top_emotion_score,
+            "candidates": candidates,
+            "recommendation": recommendation_text 
+        })
+    except Exception as e:
+        logging.error(f"[/api/predict] 처리 중 오류 발생: {e}")
+        db.session.rollback() # 혹시 모를 트랜잭션 롤백
+        return jsonify({"error": "처리 중 오류가 발생했습니다."}), 500
+
+
+@bp.route("/api/recommend", methods=["POST"])
+def api_recommend():
+    logging.info("[/api/recommend] 요청 수신됨.")
+    user_diary = request.json.get("diary")
+    predicted_emotion = request.json.get("emotion") # 감정을 직접 받음
+
+    if not user_diary or not predicted_emotion:
+        logging.warning("[/api/recommend] 일기 내용 또는 감정이 없습니다.")
+        return jsonify({"error": "일기 내용 또는 감정이 없습니다."}), 400
+
+    recommendation_text = generate_recommendation(user_diary, predicted_emotion)
+    
+    response_data = {
+        "emotion": predicted_emotion,
+        "emoji": emotion_emoji_map.get(predicted_emotion, '🤔'),
+        "recommendation": recommendation_text
+    }
+    return jsonify(response_data)
+
+
+@bp.route('/api/diaries')
+def api_diaries():
+    if 'user_id' not in session:
+        return jsonify({"error": "로그인이 필요합니다."}), 401
+
+    user_id = session['user_id']
+    year = request.args.get('year', type=int)
+    month = request.args.get('month', type=int)
+
+    logging.info(f"API 요청: user_id={user_id}, year={year}, month={month}")
+
+    if not year or not month:
+        today = datetime.date.today()
+        year = today.year
+        month = today.month
+
+    start_date = datetime.date(year, month, 1)
+    if month == 12:
+        end_date = datetime.date(year + 1, 1, 1)
+    else:
+        end_date = datetime.date(year, month + 1, 1)
+
+    logging.info(f"DB 쿼리 범위: {start_date} <= created_at < {end_date}")
+
+    user_diaries = Diary.query.filter(
+        Diary.user_id == user_id,
+        Diary.created_at >= start_date,
+        Diary.created_at < end_date
+    ).order_by(Diary.created_at.asc()).all()
+
+    diaries_data = []
+    utc_tz = datetime.timezone.utc
+    kst_tz = datetime.timezone(datetime.timedelta(hours=9))
+
+    for diary in user_diaries:
+        created_at_utc = diary.created_at
+        
+        # 타임존 정보가 없는 경우 UTC로 간주
+        if created_at_utc.tzinfo is None:
+            created_at_utc = created_at_utc.replace(tzinfo=utc_tz)
+
+        created_at_kst = created_at_utc.astimezone(kst_tz)
+
+        diaries_data.append({
+            "id": diary.id,
+            "date": created_at_kst.strftime('%Y-%m-%d'),
+            "createdAt": created_at_kst.strftime('%Y-%m-%d %H:%M:%S'),
+            "content": diary.content,
+            "emotion": diary.emotion,
+            "recommendation": diary.recommendation
+        })
+
+    return jsonify(diaries_data)
+
+
+@bp.route('/api/diaries/counts')
+def api_diaries_counts():
+    if 'user_id' not in session:
+        return jsonify({"error": "로그인이 필요합니다."}), 401
+
+    user_id = session['user_id']
+    year = request.args.get('year', type=int)
+
+    if not year:
+        year = datetime.date.today().year
+
+    # PostgreSQL은 extract를 지원하므로 원래 로직으로 복원
+    counts = db.session.query(
+        extract('month', Diary.created_at).cast(String), # 월을 문자열로 캐스팅
+        db.func.count(Diary.id)
+    ).filter(
+        Diary.user_id == user_id,
+        extract('year', Diary.created_at) == year
+    ).group_by(
+        extract('month', Diary.created_at)
+    ).all()
+
+    counts_dict = {month: count for month, count in counts}
+    
+    return jsonify(counts_dict)
+
+
+@bp.route('/my_diary')
+def my_diary():
+    if 'user_id' not in session:
+        return redirect(url_for('auth.login'))
+    
+    user_id = session.get('user_id')
+    user = User.query.get(user_id)
+    display_name = user.nickname if user.nickname else user.username
+
+    return render_template('diary.html', display_name=display_name)
+
+
+@bp.route('/mypage')
+def mypage():
+    if 'user_id' not in session:
+        return redirect(url_for('auth.login'))
+    
+    user_id = session['user_id']
+    user = User.query.get(user_id)
+    
+    user_info = {
+        'username': user.username,
+        'nickname': user.nickname,
+        'display_name': user.nickname if user.nickname else user.username
+    }
+    
+    return render_template('page.html', user_info=user_info)
+
+@bp.route('/update_nickname', methods=['POST'])
+def update_nickname():
+    if 'user_id' not in session:
+        return redirect(url_for('auth.login'))
+
+    user_id = session['user_id']
+    user = User.query.get(user_id)
+
+    new_nickname = request.form.get('nickname')
+    
+    # 닉네임이 비어있거나, 공백만 있을 경우 None으로 저장
+    if not new_nickname or not new_nickname.strip():
+        user.nickname = None
+    else:
+        user.nickname = new_nickname
+    
+    db.session.commit()
+    
+    # 세션 정보 업데이트 (선택 사항, 닉네임을 세션에 저장할 경우)
+    # session['nickname'] = user.nickname
+
+    return redirect(url_for('main.mypage'))
+
+
+
+@bp.route('/diary/save', methods=['POST'])
+def diary_save():
+    if 'user_id' not in session:
+        return jsonify({"error": "로그인이 필요합니다."}), 401
+
+    user_id = session['user_id']
+    diary_content = request.form.get('diary')
+    predicted_emotion = request.form.get('emotion')
+
+    if not diary_content or not predicted_emotion:
+        return jsonify({"error": "일기 내용이나 감정이 없습니다."}), 400
+
+    try:
+        # 추천 생성
+        recommendation_text = generate_recommendation(diary_content, predicted_emotion)
+
+        # Gemini API 실패 시 Recommender 클래스로 대체
+        if recommendation_text is None:
+            logging.info("Gemini 추천 실패. Recommender 클래스로 대체합니다.")
+            su_yoong_recs = recommender.recommend(predicted_emotion, '수용')
+            jeon_hwan_recs = recommender.recommend(predicted_emotion, '전환')
+            
+            # diary_logic.js가 파싱할 수 있는 형식으로 만듭니다.
+            recommendation_text = f"## [수용]\n"
+            for rec in su_yoong_recs:
+                recommendation_text += f"* {rec}\n"
+            
+            recommendation_text += f"\n## [전환]\n"
+            for rec in jeon_hwan_recs:
+                recommendation_text += f"* {rec}\n"
+
+        # 일기 저장
+        new_diary = Diary(
+            content=diary_content,
+            emotion=predicted_emotion,
+            recommendation=recommendation_text,
+            user_id=user_id
+        )
+        db.session.add(new_diary)
+        db.session.commit()
+
+        return jsonify({
+            "success": "일기가 성공적으로 저장되었습니다.",
+            "recommendation": recommendation_text # 클라이언트에서 바로 사용할 수 있도록 추천 내용 반환
+        }), 200
+
+    except Exception as e:
+        db.session.rollback()
+        logging.error(f"일기 저장 중 오류 발생: {e}")
+        return jsonify({"error": "일기 저장 중 오류가 발생했습니다."}), 500
+
+@bp.route('/diary/delete/<string:diary_id>', methods=['DELETE'])
+def delete_diary(diary_id):
+    if 'user_id' not in session:
+        return jsonify({"error": "로그인이 필요합니다."}), 401
+
+    diary_to_delete = Diary.query.get(diary_id)
+
+    if not diary_to_delete:
+        return jsonify({"error": "일기를 찾을 수 없습니다."}), 404
+
+    if diary_to_delete.user_id != session['user_id']:
+        return jsonify({"error": "삭제 권한이 없습니다."}), 403
+
+    try:
+        db.session.delete(diary_to_delete)
+        db.session.commit()
+        return jsonify({"success": "일기가 삭제되었습니다."}), 200
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({"error": "삭제 중 오류가 발생했습니다."}), 500
+
+@bp.route('/test/animation')
+def test_animation():
+    return render_template('test_animation.html', display_name='테스트')

src/models.py

@@ -0,0 +1,31 @@
+from . import db
+from werkzeug.security import generate_password_hash, check_password_hash
+import uuid
+from sqlalchemy.sql import func
+import datetime
+from datetime import timezone, timedelta
+
+class User(db.Model):
+    id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    nickname = db.Column(db.String(80), nullable=True)
+    
+    password_hash = db.Column(db.String(256), nullable=False)
+
+    diaries = db.relationship('Diary', backref='author', lazy=True, cascade="all, delete-orphan")
+
+    def set_password(self, password):
+        self.password_hash = generate_password_hash(password)
+
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)
+    
+class Diary(db.Model):
+    id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id = db.Column(db.String(36), db.ForeignKey('user.id'), nullable=False)
+    content = db.Column(db.Text, nullable=False)
+    emotion = db.Column(db.String(20), nullable=False)
+    recommendation = db.Column(db.Text, nullable=True)
+    created_at = db.Column(db.DateTime(timezone=True), default=func.now())
+
+    __table_args__ = (db.Index('idx_diary_user_id_created_at', "user_id", "created_at"),)

src/recommender.py

@@ -0,0 +1,31 @@
+class Recommender:
+    def __init__(self):
+        self.recommendation_db = {
+            '기쁨': { # 기쁨
+                '수용': ["음악: Pharrell Williams - Happy", "영화: 월터의 상상은 현실이 된다"],
+                '전환': ["음악: 이루마 - River Flows In You", "영화: 쇼생크 탈출"]
+            },
+            '슬픔': { # 슬픔
+                '수용': ["음악: 박효신 - 눈의 꽃", "영화: 이터널 선샤인"],
+                '전환': ["음악: 거북이 - 비행기", "영화: 월-E"]
+            },
+            '분노': { # 분노
+                '수용': ["음악: 람슈타인 - Du Hast", "영화: 존 윅"],
+                '전환': ["음악: 노라 존스 - Don't Know Why", "영화: 리틀 포레스트"]
+            },
+            '불안': { # 불안
+                '수용': ["음악: 위로가 되는 연주곡 플레이리스트", "영화: 인사이드 아웃"],
+                '전환': ["음악: Maroon 5 - Moves Like Jagger", "영화: 극한직업"]
+            },
+            '놀람': { # 놀람
+                '수용': ["영화: 식스 센스", "음악: 박진영 - 어머님이 누구니"],
+                '전환': ["음악: Bach - Air on G String", "책: 고요할수록 밝아지는 것들"]
+            },
+            '당황': { # 당황
+                '수용': ["음악: 잔잔한 Lo-fi 플레이리스트", "영화: 패터슨"],
+                '전환': ["음악: Queen - Don't Stop Me Now", "영화: 스파이더맨: 뉴 유니버스"]
+            },
+        }
+
+    def recommend(self, emotion: str, choice: str) -> list:
+        return self.recommendation_db.get(emotion, {}).get(choice, ["😥 아쉽지만, 아직 준비된 추천이 없어요."])

src/templates/_macros.html

@@ -0,0 +1,30 @@
+{% macro auth_form(title, form_action, bottom_link_url, bottom_link_text) %}
+    <div class="container">
+        <h1>{{ title }}</h1>
+        <form method="post" action="{{ form_action }}">
+            <div class="form-group">
+                <label for="username">사용자 이름</label>
+                <input type="text" id="username" name="username" required>
+            </div>
+            <div class="form-group">
+                <label for="password">비밀번호</label>
+                <input type="password" id="password" name="password" required>
+            </div>
+            <button type="submit">{{ title }}</button>
+        </form>
+        <p>{{ bottom_link_text }} <a href="{{ bottom_link_url }}">{{ '로그인' if 'signup' in bottom_link_url else '회원가입' }}</a></p>
+    </div>
+{% endmacro %}
+
+{% macro recommendation_tabs(acceptance_content, diversion_content, container_id) %}
+    <div class="rec-tabs">
+        <button class="rec-tab-btn active" data-tab="{{ container_id }}-acceptance">수용</button>
+        <button class="rec-tab-btn" data-tab="{{ container_id }}-diversion">전환</button>
+    </div>
+    <div id="{{ container_id }}-acceptance" class="rec-content active">
+        {{ acceptance_content | safe }}
+    </div>
+    <div id="{{ container_id }}-diversion" class="rec-content">
+        {{ diversion_content | safe }}
+    </div>
+{% endmacro %}

src/templates/auth_combined.html

@@ -0,0 +1,73 @@
+{% extends "base_auth.html" %}
+
+{% block title %}로그인 / 회원가입{% endblock %}
+
+{% block content %}
+<div class="book-container">
+    <div class="layer-base">
+        <div class="base-box left-form">
+            <h2>로그인</h2>
+            <form method="post" action="{{ url_for('auth.login') }}">
+                <div class="input-group">
+                    <label>아이디</label>
+                    <input type="text" name="username" required>
+                </div>
+                <div class="input-group">
+                    <label>비밀번호</label>
+                    <input type="password" name="password" required>
+                </div>
+                <button type="submit" class="action-btn">로그인</button>
+            </form>
+        </div>
+
+        <div class="base-box right-form">
+            <h2>회원가입</h2>
+            <form method="post" action="{{ url_for('auth.signup') }}">
+                <div class="input-group">
+                    <label>아이디</label>
+                    <input type="text" name="username" required>
+                </div>
+                <div class="input-group">
+                    <label>비밀번호</label>
+                    <input type="password" name="password" required>
+                </div>
+                <button type="submit" class="action-btn">가입하기</button>
+            </form>
+        </div>
+    </div>
+
+    <div class="layer-flipper" id="flipper">
+        
+        <div class="page-face front-face info-side">
+            <div class="content-wrapper">
+                <h2>당신의 오늘은<br>어땠나요?</h2>
+                <p>마음 속 이야기를<br>기록하러 오셨나요?</p>
+                <button class="ghost-btn" onclick="turnPage()">첫 일기 쓰러 가기</button>
+            </div>
+        </div>
+
+        <div class="page-face back-face info-side">
+            <div class="content-wrapper">
+                <h2>기다리고<br>있었어요!</h2>
+                <p>오늘 하루도<br>정말 수고 많으셨습니다.</p>
+                <button class="ghost-btn" onclick="turnPage()">내 일기장 열기</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    // 페이지 넘기기 함수
+    function turnPage() {
+        document.getElementById('flipper').classList.toggle('flipped');
+    }
+
+    // 회원가입 실패 시(mode=signup) 자동으로 페이지 넘겨놓기
+    document.addEventListener('DOMContentLoaded', function() {
+        const urlParams = new URLSearchParams(window.location.search);
+        if (urlParams.get('mode') === 'signup') {
+            document.getElementById('flipper').classList.add('flipped');
+        }
+    });
+</script>
+{% endblock %}

src/templates/base.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Emotion Diary{% endblock %}</title>
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/flatpickr/dist/flatpickr.min.css">
+    <script src="https://cdn.jsdelivr.net/npm/flatpickr"></script>
+    <script src="https://cdn.jsdelivr.net/npm/flatpickr/dist/l10n/ko.js"></script>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <script src="{{ url_for('static', filename='js/theme_loader.js') }}"></script>
+    {% block head %}{% endblock %}
+</head>
+<body>
+    <header class="navbar-container">
+        <nav class="navbar">
+            <a href="{{ url_for('main.home') }}" class="navbar-brand">Emotion Diary</a>
+            
+            <ul class="navbar-menu">
+                <div class="nav-marker"></div>
+
+                {% if 'user_id' in session or logged_in %}
+                    <li class="nav-item"><a href="{{ url_for('main.home') }}">일기 쓰기</a></li>
+                    <li class="nav-item"><a href="{{ url_for('main.my_diary') }}">나의 일기</a></li>
+                    <li class="nav-item"><a href="{{ url_for('main.mypage') }}">마이페이지</a></li>
+                    <li class="nav-item"><a href="{{ url_for('auth.logout') }}">로그아웃</a></li>
+                {% else %}
+                    <li class="nav-item"><a href="{{ url_for('auth.login') }}">로그인</a></li>
+                    <li class="nav-item"><a href="{{ url_for('auth.signup') }}">회원가입</a></li>
+                {% endif %}
+            </ul>
+        </nav>
+    </header>
+
+    <main class="container">
+        {% block content %}{% endblock %}
+    </main>
+
+    <script src="{{ url_for('static', filename='js/script.js') }}"></script>
+    {% block scripts %}{% endblock %}
+</body>
+</html>

src/templates/base_auth.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <title>{% block title %}인증{% endblock %}</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/base_auth.css') }}">
+</head>
+<body>
+    {% block content %}{% endblock %}
+
+    {% with messages = get_flashed_messages() %}
+      {% if messages %}
+        <script>
+          alert("{{ messages[0] }}");
+        </script>
+      {% endif %}
+    {% endwith %}
+</body>
+</html>

src/templates/diary.html

@@ -0,0 +1,81 @@
+{% extends "base.html" %}
+
+{% block title %}{{ display_name }}'s Dashboard{% endblock %}
+
+{% block head %}
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/diary.css') }}">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css') }}">
+{% endblock %}
+
+{% block content %}
+<div class="dashboard-container">
+    <!-- 1열: 좌측 사이드바 -->
+    <aside class="sidebar">
+        <div class="year-selector">
+            <button id="prev-year">◀</button>
+            <h2 id="current-year">2025</h2>
+            <button id="next-year">▶</button>
+        </div>
+                <ul class="month-list">
+                    <li class="month-item" data-month="0" style="display: flex; justify-content: space-between;"><span>Jan</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="1" style="display: flex; justify-content: space-between;"><span>Feb</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="2" style="display: flex; justify-content: space-between;"><span>Mar</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="3" style="display: flex; justify-content: space-between;"><span>Apr</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="4" style="display: flex; justify-content: space-between;"><span>May</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="5" style="display: flex; justify-content: space-between;"><span>Jun</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="6" style="display: flex; justify-content: space-between;"><span>Jul</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="7" style="display: flex; justify-content: space-between;"><span>Aug</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="8" style="display: flex; justify-content: space-between;"><span>Sep</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="9" style="display: flex; justify-content: space-between;"><span>Oct</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="10" style="display: flex; justify-content: space-between;"><span>Nov</span> <span class="diary-count"></span></li>
+                    <li class="month-item" data-month="11" style="display: flex; justify-content: space-between;"><span>Dec</span> <span class="diary-count"></span></li>
+                </ul>
+        <div class="sidebar-footer">
+            <p>Emotion Diary</p>
+        </div>
+    </aside>
+
+    <!-- 2열: 중앙 달력 -->
+    <main class="calendar-area">
+        <div class="calendar-header">
+            <h2 id="calendar-month-title">November</h2>
+            <button class="add-btn" title="오늘 날짜로 새 일기 작성 (구현 예정)">+ Add</button>
+        </div>
+        <div id="calendar"></div>
+    </main>
+
+    <!-- 3열: 우측 타임라인 -->
+    <section class="timeline-area">
+        <h2 class="timeline-title">일기 목록</h2>
+        <div id="diary-list-container">
+            <div class="placeholder">
+                <p>날짜를 선택하면<br>이곳에 일기가 표시됩니다.</p>
+            </div>
+        </div>
+    </section>
+</div>
+<!-- Recommendation Modal -->
+<div id="rec-modal-overlay" class="modal-overlay">
+    <div id="rec-modal-content" class="modal-content">
+        <button id="rec-modal-close" class="modal-close-btn">&times;</button>
+        <h2 id="rec-modal-title"></h2>
+        <div id="rec-modal-body"></div>
+    </div>
+</div>
+
+<!-- Diary Detail Modal -->
+<div id="diary-detail-modal-overlay" class="diary-detail-modal-overlay">
+    <div class="diary-detail-modal-content">
+        <button id="diary-detail-modal-close" class="diary-detail-modal-close">&times;</button>
+        <h2 id="diary-detail-title"></h2>
+        <div id="diary-detail-body">
+            <!-- 내용은 JS를 통해 동적으로 채워집니다 -->
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+<script src="{{ url_for('static', filename='js/diary_logic.js') }}"></script>
+{% endblock %}

src/templates/login.html

@@ -0,0 +1,8 @@
+{% extends "base_auth.html" %}
+{% from "_macros.html" import auth_form %}
+
+{% block title %}로그인{% endblock %}
+
+{% block content %}
+    {{ auth_form('로그인', url_for('auth.login'), url_for('auth.signup'), '계정이 없으신가요?') }}
+{% endblock %}

src/templates/main.html

@@ -0,0 +1,159 @@
+{% extends "base.html" %}
+
+{% block title %}감정 일기{% endblock %}
+
+{% block head %}
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css') }}">
+{% endblock %}
+
+{% block content %}
+    <!-- Onboarding Modal -->
+    <div id="onboarding-overlay" class="onboarding-overlay">
+        <div class="onboarding-modal">
+            <div id="slide1" class="onboarding-slide active">
+                <h2>환영합니다!</h2>
+                <p>Emotion Diary는 당신의 하루를 기록하고 감정을 분석해주는 서비스입니다.</p>
+            </div>
+            <div id="slide2" class="onboarding-slide">
+                <h2>일기 작성</h2>
+                <p>오늘 있었던 일을 자유롭게 작성해주세요. 당신의 이야기에 귀 기울일게요.</p>
+            </div>
+            <div id="slide3" class="onboarding-slide">
+                <h2>감정 분석과 음악 추천</h2>
+                <p>작성된 일기를 바탕으로 감정을 분석하고, 지금 당신에게 어울리는 음악을 추천해드립니다.</p>
+            </div>
+            <div id="slide4" class="onboarding-slide">
+                <h2>정확도 80%</h2>
+                <p>저희 서비스는 텍스트 감정 분석에서 약 80%의 정확도를 자랑합니다.</p>
+            </div>
+            <div id="slide5" class="onboarding-slide">
+                <h2>닉네임 설정</h2>
+                <p>서비스에서 사용하실 닉네임을 설정해주세요. (선택 사항)</p>
+                <input type="text" id="onboarding-nickname-input" placeholder="닉네임을 입력하세요" style="width: calc(100% - 20px); padding: 10px; margin-top: 15px; border: 1px solid #ddd; border-radius: 5px;">
+            </div>
+            <div class="onboarding-nav">
+                <button id="onboarding-prev" class="onboarding-btn" style="display: none;">이전</button>
+                <button id="onboarding-close" class="onboarding-btn">다시 보지 않기</button>
+                <div class="onboarding-dots">
+                    <span class="onboarding-dot active" data-slide="1"></span>
+                    <span class="onboarding-dot" data-slide="2"></span>
+                    <span class="onboarding-dot" data-slide="3"></span>
+                    <span class="onboarding-dot" data-slide="4"></span>
+                    <span class="onboarding-dot" data-slide="5"></span>
+                </div>
+                <button id="onboarding-next" class="onboarding-btn">다음</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 테마 색상 변경 팔레트 -->
+    <div class="theme-palette">
+        <div class="theme-option-wrapper">
+            <button class="theme-btn" data-color="default" data-theme-group="default" title="기본 테마">🎨</button>
+            <div class="sub-options" data-theme-group="default">
+                <button class="sub-option-btn" data-color="current" title="보라색">보라색</button>
+                <button class="sub-option-btn" data-color="blue" title="파랑색">파랑색</button>
+                <button class="sub-option-btn" data-color="lightyellow" title="연한 노랑색">노랑색</button>
+            </div>
+        </div>
+        <div class="theme-option-wrapper">
+            <button class="theme-btn" data-color="sunset" data-theme-group="sunset" title="저녁 노을">🌇</button>
+            <div class="sub-options" data-theme-group="sunset">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sun1.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sun1.jpg" title="저녁 노을 1">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sun2.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sun2.jpg" title="저녁 노일 2">
+            </div>
+        </div>
+        <div class="theme-option-wrapper">
+            <button class="theme-btn" data-color="forest" data-theme-group="forest" title="고요한 숲">🌳</button>
+            <div class="sub-options" data-theme-group="forest">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/forest1.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/forest1.jpg" title="고요한 숲 1">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/forest2.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/forest2.jpg" title="고요한 숲 2">
+            </div>
+        </div>
+        <div class="theme-option-wrapper">
+            <button class="theme-btn" data-color="sky" data-theme-group="sky" title="하늘 테마">☁️</button>
+            <div class="sub-options" data-theme-group="sky">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sky1.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sky1.jpg" title="하늘 1">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sky2.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sky2.jpg" title="하늘 2">
+            </div>
+        </div>
+        <div class="theme-option-wrapper">
+            <button class="theme-btn" data-color="night" data-theme-group="night" title="별빛 밤">🌃</button>
+            <div class="sub-options" data-theme-group="night">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/city1.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/city1.jpg" title="별빛 밤 1">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/city2.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/city2.jpg" title="별빛 밤 2">
+            </div>
+        </div>
+        <div class="theme-option-wrapper">
+            <button class="theme-btn" data-color="sea" data-theme-group="sea" title="푸른 바다">🌊</button>
+            <div class="sub-options" data-theme-group="sea">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sea1.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sea1.jpg" title="푸른 바다 1">
+                <img src="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sea2.jpg" data-theme-bg="https://huggingface.co/datasets/taehoon222/emotion-images/resolve/main/sea2.jpg" title="푸른 바다 2">
+            </div>
+        </div>
+    </div>
+
+    <div class="main-content">
+        <div class="diary-book">
+            
+            <div class="book-page left-page chat-container">
+                <div class="page-header">
+                    <h2>To. Clobe ✏️</h2>
+                    <span class="date-label">Nov 21</span> </div>
+                
+                <textarea id="diary" placeholder="오늘 당신의 하루는 어땠나요?&#13;&#10;솔직한 마음을 적어주세요."></textarea>
+                
+                <div class="button-container">
+                    <button id="submit-btn" disabled>분석하기</button>
+                </div>
+            </div>
+
+            <div class="book-spine"></div>
+
+            <div class="book-page right-page" id="result-container">
+                <div class="page-header">
+                    <h2>From. Cloub 💌</h2>
+                    <div id="save-action-container" style="display:none; text-align: center; margin-top: 20px;">
+                        <button id="final-save-btn" class="save-btn">일기장에 저장하기</button>
+                    </div>
+                </div>
+
+                <div id="emotion-chips" class="emotion-chips" style="display:none;"></div>
+
+                <div id="result">
+                    <div class="empty-state">
+                        <p>왼쪽 페이지에 일기를 쓰고<br>분석 버튼을 눌러주세요.</p>
+                    </div>
+                </div>
+                <div id="save-status" style="margin-top: 1rem; text-align: center;"></div>
+            </div>
+
+        </div>
+    </div>
+        
+            <!-- 감정 선택 UI (초기에는 숨김) -->
+            <div id="emotion-choice-container" style="display: none;">
+                <div class="notification">
+                    <p>AI가 당신의 감정을 복합적으로 파악했어요.<br>현재 느끼는 가장 주된 감정을 선택해주세요.</p>
+                </div>
+                <div id="emotion-chips">
+                    <!-- 감정 칩은 JS를 통해 동적으로 생성됩니다. -->
+                </div>
+            </div>
+
+            <!-- 저장 버튼 컨테이너 (초기에는 숨김) -->
+            <div class="save-button-container" style="display: none; text-align: center; margin-top: 20px;">
+                <button id="save-diary-btn">일기 저장하기</button>
+            </div>
+
+            <div id="save-status" style="margin-top: 1rem; text-align: center;"></div>
+        </div>
+    </div>
+{% endblock %}
+
+{% block scripts %}
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script src="{{ url_for('static', filename='js/main_onboarding.js') }}"></script>
+    <script src="{{ url_for('static', filename='js/main_logic.js') }}"></script>
+    <script src="{{ url_for('static', filename='js/main_theme.js') }}"></script>
+{% endblock %}

src/templates/page.html

@@ -0,0 +1,31 @@
+{% extends "base.html" %}
+
+{% block title %}{{ user_info.display_name }}님의 마이페이지{% endblock %}
+
+{% block head %}
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/page.css') }}">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css') }}">
+{% endblock %}
+
+{% block content %}
+    
+    <div class="mypage-box">
+        <h1>{{ user_info.display_name }}님의 마음 팔레트</h1>
+
+        <ul class="info-list">
+            <li>
+                <span class="label">아이디</span>
+                <span class="value">{{ user_info.username }}</span>
+            </li>
+            <li>
+                <span class="label">닉네임</span>
+                <div class="value">
+                    <form action="{{ url_for('main.update_nickname') }}" method="post" class="nickname-form">
+                        <input type="text" name="nickname" value="{{ user_info.nickname or '' }}" placeholder="닉네임을 입력하세요">
+                        <button type="submit">변경</button>
+                    </form>
+                </div>
+            </li>
+        </ul>
+    </div>
+{% endblock %}

src/templates/signup.html

@@ -0,0 +1,8 @@
+{% extends "base_auth.html" %}
+{% from "_macros.html" import auth_form %}
+
+{% block title %}회원가입{% endblock %}
+
+{% block content %}
+    {{ auth_form('회원가입', url_for('auth.signup'), url_for('auth.login'), '이미 계정이 있으신가요?') }}
+{% endblock %}

src/templates/static/css/base_auth.css

@@ -0,0 +1,121 @@
+/* [기본 설정] */
+body {
+    background: #f0f2f5;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100vh;
+    margin: 0;
+    font-family: "Spoqa Han Sans Neo", sans-serif;
+}
+
+/* --- 메인 컨테이너 --- */
+.book-container {
+    width: 800px;
+    height: 500px;
+    position: relative;
+    perspective: 1500px; /* 3D 원근감 */
+    background-color: #fff; /* 폼 배경색 */
+    border-radius: 20px;
+    box-shadow: 0 14px 28px rgba(0,0,0,0.15), 0 10px 10px rgba(0,0,0,0.12);
+    overflow: hidden; /* 둥근 모서리 밖으로 나가는 것 방지 */
+}
+
+/* [레이어 1] 바닥에 깔린 폼들 */
+.layer-base {
+    width: 100%;
+    height: 100%;
+    display: flex; /* 좌우 배치 */
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: 1;
+}
+
+.base-box {
+    width: 50%;
+    height: 100%;
+    padding: 40px;
+    box-sizing: border-box;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    text-align: center;
+}
+
+/* [레이어 2] 움직이는 페이지 (Flipper) */
+.layer-flipper {
+    width: 50%; /* 전체 너비의 절반 */
+    height: 100%;
+    position: absolute;
+    top: 0;
+    left: 50%; /* 오른쪽 절반에서 시작 */
+    
+    
+    transform-origin: left center;
+    transform-style: preserve-3d;
+    transition: transform 0.8s cubic-bezier(0.645, 0.045, 0.355, 1.000); /* 부드러운 종이 넘김 효과 */
+    z-index: 10;
+}
+
+/* 페이지가 넘어간 상태 (왼쪽으로 -180도 회전) */
+.layer-flipper.flipped {
+    transform: rotateY(-180deg);
+}
+
+/* --- 페이지의 앞면/뒷면 디자인 --- */
+.page-face {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+    backface-visibility: hidden; /* 뒷면 안 보이게 */
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    text-align: center;
+    padding: 40px;
+    box-sizing: border-box;
+    
+    /* 안내 문구 배경 (파란색 그라데이션) */
+    background: linear-gradient(135deg, #6598e5, #5540a3);
+    color: white;
+}
+
+/* 앞면 (환영합니다) - 기본 상태 */
+.front-face {
+    z-index: 2;
+    transform: rotateY(0deg);
+}
+
+/* 뒷면 (돌아오셨군요) - 미리 180도 돌려놓음 */
+.back-face {
+    z-index: 1;
+    transform: rotateY(180deg);
+}
+
+/* --- 내부 요소 스타일 (버튼, 입력창 등) --- */
+h2 { margin-bottom: 20px; font-size: 2rem; font-weight: 700; }
+.input-group { width: 100%; margin-bottom: 15px; text-align: left; }
+.input-group label { display: block; margin-bottom: 5px; font-size: 0.9rem; color: #666; }
+.input-group input { width: 100%; padding: 12px; border: 1px solid #ddd; border-radius: 8px; background: #f4f4f4; box-sizing: border-box; }
+
+/* 로그인/가입 액션 버튼 */
+.action-btn {
+    width: 100%; padding: 12px; background-color: #5540a3; color: white;
+    border: none; border-radius: 8px; font-size: 1rem; font-weight: bold;
+    cursor: pointer; margin-top: 10px; transition: 0.3s;
+}
+.action-btn:hover { background-color: #443383; }
+
+/* 유령 버튼 (페이지 넘기기용) */
+.ghost-btn {
+    background: transparent; border: 2px solid white; color: white;
+    padding: 10px 30px; border-radius: 25px; font-weight: bold;
+    cursor: pointer; margin-top: 20px; transition: 0.2s;
+}
+.ghost-btn:hover { background: white; color: #5540a3; }
+.content-wrapper p { font-size: 1.1rem; margin-bottom: 20px; line-height: 1.5; }

src/templates/static/css/diary.css

@@ -0,0 +1,488 @@
+/* --- 감정별 색상 변수 --- */
+:root {
+    --primary-theme-color: #7b68ee; /* 보라색 포인트 */
+    --background-light: #f4f7fc;
+    --text-dark: #333;
+    --text-light: #888;
+    
+    --dot-joy: #ffdd57;
+    --dot-sad: #5390e3;
+    --dot-angry: #ff6b6b;
+    --dot-anxious: #9775fa;
+    --dot-surprised: #ffa94d;
+    --dot-hurt: #48d1cc;
+    --dot-default: #e0e0e0;
+}
+
+/* --- 전체 레이아웃 --- */
+.dashboard-container {
+    display: flex;
+    width: 95%;
+    max-width: 1400px;
+    height: 750px;
+    margin: 2rem auto;
+    margin-top: 5rem;
+    background-color: white;
+    border-radius: 20px;
+    box-shadow: 0 20px 50px rgba(0, 0, 0, 0.1);
+    overflow: hidden;
+    font-family: 'Spoqa Han Sans Neo', sans-serif;
+}
+
+/* --- 1. 좌측 사이드바 --- */
+.sidebar {
+    width: 200px;
+    background-color: var(--primary-theme-color);
+    color: white;
+    padding: 0.5rem 0;
+    display: flex;
+    flex-direction: column;
+    flex-shrink: 0;
+}
+
+.year-selector {
+    display: flex;
+    justify-content: space-around;
+    align-items: center;
+    padding: 0 1.5rem;
+    margin-bottom: 2rem;
+}
+.year-selector h2 {
+    font-size: 1.5rem;
+    margin: 0;
+}
+.year-selector button {
+    background: none;
+    border: none;
+    color: white;
+    font-size: 1.2rem;
+    cursor: pointer;
+    opacity: 0.8;
+    transition: opacity 0.2s;
+}
+.year-selector button:hover {
+    opacity: 1;
+}
+
+.month-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    flex-grow: 1;
+}
+.month-item {
+    padding: 0.7rem 2rem;
+    font-size: 1.3rem;
+    cursor: pointer;
+    transition: background-color 0.2s;
+    opacity: 0.7;
+    position: relative;
+}
+.month-item:hover, .month-item.active {
+    background-color: rgba(255, 255, 255, 0.1);
+    opacity: 1;
+}
+.month-item.active::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 0;
+    width: 4px;
+    height: 100%;
+    background-color: white;
+}
+
+.sidebar-footer {
+    text-align: center;
+    font-size: 0.9rem;
+    opacity: 0.6;
+}
+
+/* --- 2. 중앙 달력 --- */
+.calendar-area {
+    flex-grow: 1;
+    padding: 2rem 2.5rem;
+    background-color: #fff;
+    display: flex;
+    flex-direction: column;
+}
+.calendar-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+.calendar-header h2 {
+    font-size: 2rem;
+    color: var(--text-dark);
+    margin: 0;
+}
+.add-btn {
+    background-color: var(--primary-theme-color);
+    color: white;
+    border: none;
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    font-size: 1.8rem;
+    cursor: pointer;
+    transition: transform 0.2s;
+}
+.add-btn:hover { transform: scale(1.1); }
+
+/* Flatpickr 커스텀 */
+#calendar { 
+    flex-grow: 1; 
+    display: flex;
+}
+.flatpickr-calendar {
+    width: 100% !important;
+    max-width: none !important;
+    padding: 0 !important;
+    height: 100%;
+    background: transparent;
+    box-shadow: none;
+    font-family: inherit;
+    display: flex;
+    flex-direction: column;
+}
+.flatpickr-innerContainer { 
+    height: 100%; 
+    display: flex; 
+    flex-direction: column;
+    flex-grow: 1;
+}
+
+.flatpickr-rContainer {
+    flex-grow: 1;
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+}
+
+/* --- 요일 헤더 정렬 수정 (Weekday Alignment Fix) --- */
+
+.flatpickr-weekdays {
+    display: flex !important; /* Grid 대신 Flex 사용 */
+    width: 100% !important;
+    padding: 0 2.5rem !important; 
+    box-sizing: border-box !important;
+    margin: 0 0 10px 0 !important;
+    overflow: hidden; /* 넘치는 것 방지 */
+}
+
+span.flatpickr-weekday {
+    /* 7등분 강제 적용 (100% / 7 = 14.2857%) */
+    flex: 1 0 14.28% !important; 
+    max-width: 14.28% !important;
+    
+    display: flex !important;
+    justify-content: center !important;
+    align-items: center !important;
+    
+    color: #888 !important;
+    font-weight: 600 !important;
+    font-size: 0.9rem !important;
+    margin: 0 !important;
+}
+.flatpickr-days {
+    width: 100%;
+    flex-grow: 1;
+}
+
+.dayContainer {
+    display: grid !important;
+    grid-template-columns: repeat(7, 1fr) !important;
+    width: 100% !important;
+    min-width: 100% !important;
+    max-width: 100% !important;
+    height: 100%;
+    justify-items: center !important;
+    gap: 0 !important;
+    padding: 0 2.5rem !important; /* Match weekday padding */
+    box-sizing: border-box; /* Match weekday box-sizing */
+}
+
+.flatpickr-day {
+    width: 100% !important;
+    max-width: none !important;
+    margin: 0 !important;
+    height: 80px !important; /* 원래 높이 유지 */
+    border-radius: 12px;
+    position: relative;
+    z-index: 1;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    transition: background-color 0.2s, color 0.2s; /* color transition 추가 */
+    font-size: 1.4rem; 
+    overflow: hidden; /* 가상요소가 둥근 모서리를 넘지 않도록 */
+}
+
+/* 날짜 숫자 스타일 */
+.flatpickr-day span.flatpickr-day-num {
+    position: relative;
+    z-index: 2; /* 배경보다 위에 오도록 */
+}
+
+/* 일기가 있는 날의 가상요소 (배경 역할) */
+.flatpickr-day.has-diary::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: 1; /* 숫자보다 뒤에 오도록 */
+    transition: background-color 0.2s;
+}
+
+.flatpickr-day.today {
+    border: 1px solid var(--primary-theme-color);
+}
+
+.flatpickr-day:not(.has-diary):hover { /* 일기가 없는 날짜에만 적용 */
+    background-color: #f0edff;
+}
+
+.flatpickr-day.has-diary:hover::before { /* 일기가 있는 날짜는 밝기만 조절 */
+    filter: brightness(90%);
+}
+
+.flatpickr-day.selected {
+    border: 2px solid var(--primary-theme-color); /* 배경색 대신 테두리로 선택 표시 */
+}
+/* .flatpickr-day.selected::before 규칙은 완전히 제거됨 */
+
+
+.flatpickr-day.prevMonthDay, .flatpickr-day.nextMonthDay { color: #ccc; }
+
+.flatpickr-day.has-diary {
+    color: white; /* 기본 텍스트 색상을 흰색으로 변경 */
+}
+
+/* 감정별 배경색 (가상요소에 적용) */
+.flatpickr-day.has-diary.bg-기쁨::before { background-color: var(--dot-joy); }
+.flatpickr-day.has-diary.bg-슬픔::before { background-color: var(--dot-sad); }
+.flatpickr-day.has-diary.bg-분노::before { background-color: var(--dot-angry); }
+.flatpickr-day.has-diary.bg-불안::before { background-color: var(--dot-anxious); }
+.flatpickr-day.has-diary.bg-당황::before { background-color: var(--dot-surprised); }
+.flatpickr-day.has-diary.bg-상처::before { background-color: var(--dot-hurt); }
+.flatpickr-day.has-diary.bg-default::before { background-color: var(--dot-default); }
+
+.flatpickr-day.has-diary.bg-기쁨 span.flatpickr-day-num,
+.flatpickr-day.has-diary.bg-당황 span.flatpickr-day-num,
+.flatpickr-day.has-diary.bg-default span.flatpickr-day-num {
+    color: #333; /* 밝은 배경색에 어두운 글자색 적용 */
+}
+
+
+.flatpickr-day.today.has-diary {
+    border: none; /* 배경색이 채워지므로 테두리 제거 */
+}
+
+
+
+/* --- 3. 우측 타임라인 --- */
+.timeline-area {
+    width: 350px;
+    background-color: #fcfcfc;
+    border-left: 1px solid #f0f0f0;
+    padding: 2rem;
+    overflow-y: auto;
+    flex-shrink: 0;
+}
+.timeline-title {
+    font-size: 1.5rem;
+    color: var(--text-dark);
+    margin: 0 0 2rem 0;
+}
+
+.timeline-area .placeholder {
+    text-align: center;
+    color: var(--text-light);
+    padding-top: 5rem;
+}
+
+#diary-list-container { position: relative; }
+
+.timeline-item {
+    position: relative;
+    padding-left: 30px;
+    padding-bottom: 25px;
+    border-left: 2px solid #e0e0e0;
+}
+/* 타임라인 마지막 아이템의 선 제거 */
+.timeline-item:last-child { border-left: 2px solid transparent; }
+
+/* 타임라인 점 */
+.timeline-item::before {
+    content: '';
+    position: absolute;
+    left: -9px; /* (16px / 2) - 2px */
+    top: 0;
+    width: 16px;
+    height: 16px;
+    border-radius: 50%;
+    background-color: white;
+    border: 3px solid var(--primary-theme-color);
+}
+.timeline-item.item-기쁨::before { border-color: var(--dot-joy); }
+.timeline-item.item-슬픔::before { border-color: var(--dot-sad); }
+.timeline-item.item-분노::before { border-color: var(--dot-angry); }
+.timeline-item.item-불안::before { border-color: var(--dot-anxious); }
+.timeline-item.item-당황::before { border-color: var(--dot-surprised); }
+.timeline-item.item-상처::before { border-color: var(--dot-hurt); }
+.timeline-item.item-default::before { border-color: var(--dot-default); }
+
+
+.item-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+}
+.item-time {
+    font-weight: 600;
+    color: var(--text-dark);
+}
+.item-emotion {
+    font-size: 1.2rem;
+}
+
+.item-controls {
+    display: flex;
+    align-items: center;
+    gap: 10px; /* 이모지와 삭제 버튼 사이 간격 */
+}
+
+.delete-diary-btn {
+    background: none;
+    border: 1px solid #ff6b6b;
+    color: #ff6b6b;
+    padding: 2px 8px;
+    font-size: 0.8rem;
+    border-radius: 5px;
+    cursor: pointer;
+    transition: background-color 0.2s, color 0.2s;
+}
+
+.delete-diary-btn:hover {
+    background-color: #ff6b6b;
+    color: white;
+}
+
+.item-content {
+    font-size: 0.9rem;
+    line-height: 1.6;
+    color: #666;
+    background-color: white;
+    padding: 15px;
+    border-radius: 10px;
+    border: 1px solid #f0f0f0;
+}
+.item-content h3 {
+    font-size: 1rem;
+    margin: 0 0 10px 0;
+}
+.item-content p {
+    margin: 0;
+}
+
+.item-recommendations {
+    margin-top: 15px;
+    padding-top: 15px;
+    border-top: 1px solid #f0f0f0;
+}
+
+.item-recommendations h4 {
+    font-size: 0.9rem;
+    font-weight: 600;
+    color: var(--text-dark);
+    margin: 0 0 10px 0;
+}
+
+.item-recommendations ul {
+    list-style-type: '🎵';
+    padding-left: 20px;
+    margin: 0;
+    font-size: 0.9rem;
+    color: #666;
+}
+
+.item-recommendations li {
+    padding-left: 8px;
+    margin-bottom: 5px;
+}
+.item-content ul {
+    padding-left: 20px;
+    margin: 10px 0 0 0;
+}
+.item-content li {
+    margin-bottom: 5px;
+}
+
+/* --- 상세 정보 모달 스타일 --- */
+.diary-detail-modal-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.6);
+    display: none; /* 기본적으로 숨김 */
+    justify-content: center;
+    align-items: center;
+    z-index: 1001;
+    backdrop-filter: blur(5px);
+}
+
+.diary-detail-modal-content {
+    background-color: white;
+    padding: 30px 40px;
+    border-radius: 15px;
+    width: 90%;
+    max-width: 600px;
+    max-height: 80vh;
+    overflow-y: auto;
+    box-shadow: 0 5px 20px rgba(0,0,0,0.2);
+    position: relative;
+}
+
+.diary-detail-modal-close {
+    position: absolute;
+    top: 15px;
+    right: 20px;
+    font-size: 2rem;
+    color: #aaa;
+    background: none;
+    border: none;
+    cursor: pointer;
+}
+
+#diary-detail-title {
+    font-size: 1.8rem;
+    margin-bottom: 20px;
+    color: var(--text-dark);
+}
+
+#diary-detail-body {
+    font-size: 1rem;
+    line-height: 1.7;
+    color: #444;
+}
+
+#diary-detail-body .diary-content-section {
+    margin-bottom: 25px;
+    padding-bottom: 20px;
+    border-bottom: 1px solid #eee;
+}
+#diary-detail-body .diary-content-section h3 {
+    font-size: 1.2rem;
+    margin-bottom: 10px;
+    color: var(--primary-theme-color);
+}
+
+#diary-detail-body #rec-container h3 {
+    margin-bottom: 15px;
+}

src/templates/static/css/main.css

@@ -0,0 +1,651 @@
+/* --- 🛸 매직 캡슐 내비게이션 바 (Magic Capsule Navbar) --- */
+
+.navbar-container {
+    position: fixed;
+    top: 20px;
+    left: 0;
+    width: 100%;
+    display: flex;
+    justify-content: center;
+    z-index: 1000;
+}
+
+.navbar {
+    display: flex;
+    align-items: center;
+    gap: 30px;
+    padding: 8px 15px;
+    border-radius: 50px; /* 둥근 캡슐 모양 */
+    
+    /* 글래스모피즘 (유리 효과) */
+    background: rgba(255, 255, 255, 0.7);
+    backdrop-filter: blur(15px);
+    -webkit-backdrop-filter: blur(15px);
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.05);
+    border: 1px solid rgba(255, 255, 255, 0.8);
+}
+
+.navbar-brand {
+    font-weight: 800;
+    font-size: 1.1rem;
+    color: var(--primary-color);
+    text-decoration: none;
+    padding: 0 15px;
+    letter-spacing: -0.5px;
+}
+
+/* 메뉴 리스트 */
+.navbar-menu {
+    position: relative; /* 마커의 기준점 */
+    display: flex;
+    flex-direction: row; /* Added */
+    align-items: center; /* Added */
+    list-style: none;
+    margin: 0;
+    padding: 5px;
+    background: rgba(0,0,0,0.03); /* 메뉴 뒤 연한 트랙 */
+    border-radius: 30px;
+}
+
+.nav-item {
+    position: relative;
+    z-index: 2; /* 마커보다 위에 위치 */
+}
+
+.nav-item a {
+    display: block;
+    padding: 8px 20px;
+    text-decoration: none;
+    color: #666;
+    font-weight: 600;
+    font-size: 0.9rem;
+    border-radius: 30px;
+    transition: color 0.3s;
+}
+
+/* 마우스 올렸을 때 글자색 변경 */
+.nav-item a:hover {
+    color: var(--primary-color);
+}
+
+/* ✨ 움직이는 하이라이트 (Marker) */
+.nav-marker {
+    position: absolute;
+    top: 5px;
+    left: 5px;
+    width: 0; /* JS로 제어 */
+    height: calc(100% - 10px);
+    background: white;
+    border-radius: 25px;
+    box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+    transition: all 0.3s cubic-bezier(0.5, 0, 0, 1); /* 부드러운 이동 */
+    z-index: 1;
+    opacity: 0; /* 처음엔 숨김 */
+}
+
+.copyright-dropdown {
+    position: relative;
+    margin-left: 1rem;
+}
+
+.copyright-toggle {
+    cursor: pointer;
+    font-size: 0.9rem;
+    color: var(--light-text-color);
+    border: 1px solid #ddd;
+    padding: 4px 8px;
+    border-radius: 6px;
+    transition: background-color 0.2s;
+}
+.copyright-toggle:hover {
+    background-color: #f5f5f5;
+}
+
+.copyright-content {
+    display: none;
+    position: absolute;
+    top: 120%;
+    left: 0;
+    background-color: white;
+    border-radius: 8px;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+    padding: 1rem;
+    z-index: 1001; /* Onboarding is 1000 */
+    width: 220px;
+    border: 1px solid #eee;
+    opacity: 0;
+    transform: translateY(-10px);
+    transition: opacity 0.2s, transform 0.2s;
+    pointer-events: none;
+}
+
+.copyright-content p {
+    margin: 0.5rem 0;
+    font-size: 0.85rem;
+    color: #555;
+}
+.copyright-content p:first-child {
+    margin-top: 0;
+}
+.copyright-content p:last-child {
+    margin-bottom: 0;
+}
+
+.copyright-dropdown:hover .copyright-content {
+    display: block;
+    opacity: 1;
+    transform: translateY(0);
+    pointer-events: auto;
+}
+
+/* --- 메인 콘텐츠 스타일 --- */
+/* --- 📖 펼쳐진 다이어리 스타일 (Book Spread Design) --- */
+
+/* 1. 메인 레이아웃 */
+.main-content {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    min-height: 80vh; /* 화면 중앙 정렬 */
+    margin-top: 1.5rem;
+    padding: 10px;
+}
+
+/* 2. 다이어리 전체 프레임 */
+/* --- 1. 다이어리 크기 확대 (Big Size) --- */
+.diary-book {
+    display: flex;
+    width: 70vw;            /* 화면 너비의 70%까지 사용 */
+    max-width: 1600px;     /* 최대 너비 1600px */
+    min-width: 1200px;      /* 최소 너비 1200px 강제 */
+    height: 750px;         /* 높이 고정 */
+    margin-top: 5rem; 
+    background-color: #fdfbf7;
+    border-radius: 20px;
+    box-shadow: 0 30px 60px rgba(0,0,0,0.15), 0 0 0 12px #5d4037;
+    overflow: hidden; 
+    position: relative;
+
+    margin: 0 auto; /* 수평 중앙 정렬 */
+
+}
+
+/* --- 2. 페이지 내부 스크롤 추가 (잘림 방지) --- */
+.book-page {
+    flex: 1;
+    /* 패딩을 조금 더 늘려서 시원하게 (40px -> 60px) */
+    padding: 40px 50px; 
+    display: flex;
+    flex-direction: column;
+    position: relative;
+    background-image: linear-gradient(to right, rgba(0,0,0,0.02) 0%, rgba(0,0,0,0) 5%);
+    
+    /* 스크롤바 숨김 유지 */
+    overflow-y: auto;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+     min-width:0;
+}
+
+/* (선택) 스크롤바를 예쁘게 꾸미기 */
+.book-page::-webkit-scrollbar {
+    display: none;
+}
+.book-page::-webkit-scrollbar-track {
+    background: transparent;
+}
+.book-page::-webkit-scrollbar-thumb {
+    background-color: #e0e0e0;
+    border-radius: 4px;
+}
+.book-page::-webkit-scrollbar-thumb:hover {
+    background-color: #ccc;
+}
+
+.page-header {
+    margin-bottom: 0.5rem;
+}
+
+/* --- 3. 입력창 크기 대응 --- */
+textarea {
+    flex-grow: 1;
+    border: none;
+    background: transparent;
+    font-size: 1.1rem;
+    
+    /* [수정] 줄 높이와 배경 패턴 간격을 줄여서 더 많이 쓰게 함 */
+    line-height: 2rem; /* 줄 간격 (기존 유지하거나 1.8rem으로 줄여도 됨) */
+    
+    resize: none;
+    outline: none;
+    
+    /* 배경 줄무늬 간격도 line-height와 똑같이 맞춰야 함 */
+    background-image: linear-gradient(transparent 95%, #e0e0e0 95%);
+    background-size: 100% 2rem; /* 2rem 간격 */
+    
+    padding: 0 10px; /* 좌우 여백 */
+    font-family: inherit;
+    
+    /* 스크롤바 숨김 */
+    scrollbar-width: none; 
+}
+
+/* 9. 오른쪽 빈 화면 상태 */
+.empty-state {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100%;
+    color: #aaa;
+    text-align: center;
+    font-size: 0.95rem;
+}
+
+/* --- 기존 기능 호환성 유지 --- */
+/* 찢어지는 애니메이션용 클래스 재조정 */
+
+#submit-btn {
+    width: 100%;
+    background-color: var(--primary-color);
+    color: white;
+    padding: 14px;
+    border-radius: 8px;
+    border: none;
+    font-size: 18px;
+    font-weight: bold;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+#submit-btn:hover {
+    background-color: var(--primary-hover-color);
+}
+#submit-btn:disabled {
+    background-color: #cccccc;
+    cursor: not-allowed;
+}
+
+#result {
+    background: #ffffff;
+    border-radius: 15px; /* 둥글게 */
+    padding: 25px;       /* 내부 여백 넉넉하게 */
+    margin-top: 15px;    /* 헤더("AI의 답장")와 간격 띄우기 */
+    /* 그림자 + 테두리로 카드 느낌 내기 */
+    box-shadow: 0 4px 15px rgba(0,0,0,0.05); 
+    border: 1px solid #eee;
+    
+    font-size: 1rem;
+    color: #444;
+    line-height: 1.7;
+    width:100%;
+    box-sizing: border-box;
+}
+
+.rec-tabs {
+    display: flex;
+    margin-top: 1.5rem;
+    margin-bottom: 1rem;
+    border-bottom: 1px solid #ddd;
+}
+.rec-tab-btn {
+    padding: 10px 15px;
+    cursor: pointer;
+    border: none;
+    background-color: transparent;
+    font-size: 1rem;
+    color: var(--light-text-color);
+    border-bottom: 2px solid transparent;
+    margin-bottom: -1px;
+}
+.rec-tab-btn.active {
+    color: var(--primary-color);
+    border-bottom-color: var(--primary-color);
+    font-weight: 600;
+}
+.rec-content {
+    display: none;
+}
+.rec-content.active {
+    display: block;
+}
+
+    /* --- 온보딩 슬라이드 스타일 --- */
+.onboarding-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.6);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 1000;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.3s, visibility 0.3s;
+}
+.onboarding-overlay.active {
+    opacity: 1;
+    visibility: visible;
+}
+.onboarding-modal {
+    background-color: white;
+    padding: 30px 40px;
+    border-radius: 15px;
+    width: 90%;
+    max-width: 500px;
+    box-shadow: 0 5px 20px rgba(0,0,0,0.2);
+    transform: scale(0.9);
+    transition: transform 0.3s;
+}
+.onboarding-overlay.active .onboarding-modal {
+    transform: scale(1);
+}
+.onboarding-slide {
+    display: none;
+    text-align: center;
+}
+.onboarding-slide.active {
+    display: block;
+}
+.onboarding-slide h2 {
+    color: var(--primary-color);
+    margin-bottom: 15px;
+}
+.onboarding-slide p {
+    font-size: 1rem;
+    color: var(--light-text-color);
+    line-height: 1.6;
+}
+.onboarding-nav {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-top: 25px;
+}
+.onboarding-dots {
+    display: flex;
+    gap: 8px;
+}
+.onboarding-dot {
+    width: 10px;
+    height: 10px;
+    background-color: #ccc;
+    border-radius: 50%;
+    cursor: pointer;
+}
+.onboarding-dot.active {
+    background-color: var(--primary-color);
+}
+.onboarding-btn {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    padding: 10px 20px;
+    border-radius: 5px;
+    cursor: pointer;
+    font-weight: 500;
+}
+.onboarding-btn:hover {
+    background-color: var(--primary-hover-color);
+}
+#onboarding-close {
+    background-color: transparent;
+    color: var(--light-text-color);
+}
+
+/* --- 테마 팔레트 스타일 --- */
+.theme-palette {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    z-index: 100;
+}
+.theme-btn {
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    border: 2px solid white;
+    cursor: pointer;
+    font-size: 24px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.2);
+    transition: transform 0.2s;
+}
+.theme-btn:hover {
+    transform: scale(1.1);
+}
+
+.theme-option-wrapper {
+    position: relative;
+    display: flex;
+    justify-content: flex-end;
+}
+
+.sub-options {
+    display: none;
+    position: absolute;
+    right: 60px; /* theme-btn width + gap */
+    top: 50%;
+    transform: translateY(-50%);
+    align-items: center;
+    gap: 10px;
+    background-color: rgba(255, 255, 255, 0.8);
+    padding: 8px;
+    border-radius: 10px;
+    backdrop-filter: blur(4px);
+    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+}
+
+.theme-option-wrapper.active .sub-options {
+    display: flex;
+}
+
+.sub-options img, .sub-option-btn {
+    width: 40px;
+    height: 40px;
+    border-radius: 6px;
+    cursor: pointer;
+    border: 1px solid rgba(0,0,0,0.05);
+    box-shadow: 0 1px 4px rgba(0,0,0,0.1);
+    object-fit: cover;
+}
+.sub-option-btn {
+    background-color: white;
+    font-size: 12px;
+    padding: 0;
+}
+.rec-btn {
+    background-color: #f0f0f0;
+    border: 1px solid #ddd;
+    padding: 8px 12px;
+    border-radius: 6px;
+    cursor: pointer;
+    margin-right: 10px;
+    font-size: 14px;
+}
+.rec-btn.active {
+    background-color: var(--primary-color);
+    color: white;
+    border-color: var(--primary-color);
+}
+#result table {
+    width: 100%;            /* 부모 박스 너비에 딱 맞춤 */
+    table-layout: fixed;    /* [핵심] 내용이 길어도 테이블이 늘어나지 않게 고정 */
+    border-collapse: collapse;
+    margin-top: 15px;
+    font-size: 0.95rem;
+    background-color: #fafafa; /* 표 배경색 */
+    border-radius: 8px;
+    overflow: hidden; /* 둥근 모서리 적용 */
+}
+
+#result th, #result td {
+    padding: 12px 15px;
+    border-bottom: 1px solid #eee;
+    word-break: keep-all; /* 한글 단어 안 끊기게 */
+    vertical-align: middle; /* 세로 중앙 정렬 */
+}
+
+/* 첫 번째 칸(종류) 너비 줄이기 */
+#result th:first-child, #result td:first-child {
+    width: 60px; /* '종류' 칸은 좁게 */
+    text-align: center;
+    font-weight: bold;
+    color: var(--primary-color);
+    background-color: #f0f5ff; /* 헤더 배경색 */
+}
+
+/* 두 번째 칸(추천 내용) */
+#result td:last-child {
+    text-align: left;
+    font-size: 0.9rem;
+    color: #555;
+    
+    /* [핵심] 2줄 넘어가면 ... 처리 */
+    display: -webkit-box;
+    -webkit-line-clamp: 2; 
+    line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    
+    /* 부드러운 전환 */
+    transition: all 0.3s ease;
+    cursor: help; /* 마우스 올리면 물음표 커서 */
+}
+
+#result td:last-child:hover {
+    -webkit-line-clamp: unset; /* 줄 제한 해제 */
+    line-clamp: unset;
+    background-color: #fff;    /* 읽기 편하게 배경 밝게 */
+    color: #000;
+    z-index: 10;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.1); /* 살짝 띄우기 */
+    border-radius: 5px;
+    position: relative; /* 위로 뜨게 하기 위해 */
+}
+
+/* --- 감정 선택 UI 스타일 --- */
+#emotion-choice-container {
+    background-color: #f0f8ff;
+    border-radius: 8px;
+    padding: 20px;
+    margin-top: 20px;
+    border: 1px solid #bde0fe;
+}
+
+#emotion-chips {
+    display: flex;
+    justify-content: center;
+    gap: 15px;
+    flex-wrap: wrap;
+}
+
+.emotion-chip {
+    display: flex;
+    align-items: center;
+    background-color: #f0f0f0;
+    border: 1px solid #ddd;
+    border-radius: 20px; /* 캡슐 모양 */
+    padding: 8px 16px;
+    font-size: 1rem;
+    cursor: pointer;
+    transition: background-color 0.2s, border-color 0.2s, transform 0.1s;
+    user-select: none;
+}
+
+.emotion-chip:hover {
+    background-color: #e0e0e0;
+    transform: translateY(-2px);
+}
+
+.emotion-chip.active {
+    background-color: var(--primary-color);
+    color: white;
+    border-color: var(--primary-hover-color);
+    font-weight: bold;
+}
+
+.score-badge {
+    margin-left: 8px;
+    background-color: rgba(0, 0, 0, 0.1);
+    color: #333;
+    padding: 3px 6px;
+    font-size: 0.75rem;
+    font-weight: bold;
+    border-radius: 8px;
+}
+
+.emotion-chip.active .score-badge {
+    background-color: rgba(255, 255, 255, 0.2);
+    color: white;
+}
+
+/* --- 일기 저장하기 버튼 위치 조정 --- */
+#save-action-container {
+    /* 버튼이 오른쪽 정렬되도록 */
+    display: flex; 
+    justify-content: flex-end; 
+    margin:0;
+}
+
+.save-btn {
+    /* 버튼 디자인 조금 더 예쁘게 */
+    background-color: var(--primary-color);
+    color: white;
+    padding: 10px 20px;
+    border-radius: 50px;
+    border: none;
+    font-weight: bold;
+    box-shadow: 0 4px 10px rgba(101, 152, 229, 0.4);
+    transition: transform 0.2s;
+}
+.save-btn:hover {
+    transform: translateY(-2px);
+}
+/* --- 결과 표시 헤더 --- */
+.result-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start; /* Align to the top */
+    margin-bottom: 1rem;
+    padding-bottom: 1rem;
+    border-bottom: 1px solid #eee;
+}
+
+.result-title p {
+    margin: 0;
+}
+
+/* Make the save button container part of the flex layout */
+.result-header .save-button-container {
+    margin-top: 0;
+}
+
+/* --- 로딩 프로그레스 바 --- */
+.progress-bar-container {
+    width: 100%;
+    background-color: #e0e0e0;
+    border-radius: 4px;
+    margin: 20px 0;
+    overflow: hidden; /* Ensures the inner bar stays within the rounded corners */
+}
+.progress-bar {
+    width: 0%;
+    height: 10px;
+    background-color: var(--primary-color);
+    border-radius: 4px;
+    transition: width 0.2s ease-in-out;
+}
+.loading-text {
+    text-align: center;
+    margin-top: 10px;
+    color: #555;
+    font-size: 0.9rem;
+}

src/templates/static/css/page.css

@@ -0,0 +1,73 @@
+/* mypage css part*/
+.mypage-box {
+    width: 100%; 
+    max-width: 600px;
+    margin: 0 auto;
+    padding: 4rem 2rem 2rem;
+    margin-top: 5rem;
+    background-color: white;
+    border-radius: 8px;
+    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+}
+
+h1 {
+   
+    font-weight: 700;
+    color: var(--primary-color);
+    font-size: 2rem;
+    text-align: center; 
+    margin-bottom: 0.1rem;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px solid #000000; 
+}
+.info-list {
+    list-style: none;
+    padding: 0;
+}
+
+.info-list li {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1rem 0;
+    border-bottom: 1px solid #000000;
+}
+
+.info-list li:last-child {
+    border-bottom: none;
+}
+
+.info-list .label {
+    font-weight: 500;
+    color: var(--light-text-color);
+}
+
+.info-list .value {
+    font-weight: 700;
+}
+
+.nickname-form {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.nickname-form input {
+    flex-grow: 1;
+    padding: 0.5rem;
+    border: 1px solid #000000;
+    border-radius: 4px;
+}
+
+.nickname-form button {
+    padding: 0.5rem 1rem;
+    border: none;
+    background-color: var(--primary-color);
+    color: white;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+
+.nickname-form button:hover {
+    background-color: var(--primary-hover-color);
+}

src/templates/static/css/style.css

@@ -0,0 +1,49 @@
+@import url('https://cdn.jsdelivr.net/gh/spoqa/spoqa-han-sans@latest/css/SpoqaHanSansNeo.css');
+
+:root {
+    --primary-color: #6598e5;
+    --primary-hover-color: #5540a3;
+    --text-color: #333;
+    --light-text-color: #666;
+    --danger-color: #e74c3c;
+    --font-family: 'Spoqa Han Sans Neo', sans-serif;
+}
+
+body {
+    font-family: var(--font-family);
+    margin: 0;
+    background: linear-gradient(135deg, #ece9f7, #cacae0);
+    color: var(--text-color);
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+}
+
+.navbar {
+    background-color: white;
+    padding: 10px 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    flex-shrink: 0;
+}
+.navbar-brand {
+    color: var(--primary-color);
+    font-size: 1.5rem;
+    font-weight: 700;
+    text-decoration: none;
+}
+.navbar-menu a, .navbar-menu span {
+    color: #333;
+    text-decoration: none;
+    font-weight: 500;
+    margin-left: 1rem;
+}
+
+.container {
+    flex-grow: 1;
+    padding: 3rem;
+    width: 100%;
+    box-sizing: border-box;
+}

src/templates/static/js/diary_logic.js

@@ -0,0 +1,349 @@
+document.addEventListener('DOMContentLoaded', () => {
+    // --- Emotion Map ---
+    const emotionMap = {
+        '기쁨': { emoji: '😄', bgClass: 'bg-기쁨', itemClass: 'item-기쁨' },
+        '슬픔': { emoji: '😢', bgClass: 'bg-슬픔', itemClass: 'item-슬픔' },
+        '분노': { emoji: '😠', bgClass: 'bg-분노', itemClass: 'item-분노' },
+        '불안': { emoji: '😟', bgClass: 'bg-불안', itemClass: 'item-불안' },
+        '당황': { emoji: '😮', bgClass: 'bg-당황', itemClass: 'item-당황' },
+        '상처': { emoji: '💔', bgClass: 'bg-상처', itemClass: 'item-상처' },
+        'default': { emoji: '🤔', bgClass: 'bg-default', itemClass: 'item-default' }
+    };
+
+    // --- DOM Elements ---
+    const currentYearEl = document.getElementById('current-year');
+    const prevYearBtn = document.getElementById('prev-year');
+    const nextYearBtn = document.getElementById('next-year');
+    const monthList = document.querySelector('.month-list');
+    const calendarMonthTitle = document.getElementById('calendar-month-title');
+    const diaryListContainer = document.getElementById('diary-list-container');
+    console.log("diaryListContainer element:", diaryListContainer); // 요소 확인 로그
+    const recModalOverlay = document.getElementById('rec-modal-overlay');
+    const recModalTitle = document.getElementById('rec-modal-title');
+    const recModalBody = document.getElementById('rec-modal-body');
+    const recModalCloseBtn = document.getElementById('rec-modal-close');
+    
+    // --- State ---
+    let diaryDataByDate = {};
+    let currentYear, currentMonth;
+    let fp; // flatpickr instance
+    let lastFetchedYear = null; // 월별 카운트를 마지막으로 가져온 연도
+
+    // --- Functions ---
+
+    async function updateMonthlyCounts(year) {
+        if (year === lastFetchedYear) return; // 이미 해당 연도의 데이터를 가져왔으면 실행 안함
+
+        try {
+            const response = await fetch(`/api/diaries/counts?year=${year}`);
+            if (!response.ok) throw new Error('Failed to load diary counts.');
+            const counts = await response.json();
+            
+            document.querySelectorAll('.month-item').forEach(item => {
+                const month_key = (parseInt(item.dataset.month) + 1).toString(); // 월 번호를 문자열로 변환
+                const countSpan = item.querySelector('.diary-count');
+                const count = counts[month_key] || 0; // 문자열 키로 접근
+                
+                if (count > 0) {
+                    countSpan.textContent = count;
+                } else {
+                    countSpan.textContent = '';
+                }
+            });
+            lastFetchedYear = year; // 마지막으로 가져온 연도 기록
+        } catch (error) {
+            console.error("Error fetching diary counts:", error);
+        }
+    }
+
+    async function fetchDiaries(year, month) {
+        try {
+            console.log(`Fetching diaries for year: ${year}, month: ${month}`);
+            const response = await fetch(`/api/diaries?year=${year}&month=${month}`);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Diary data failed to load. Status: ${response.status}, Message: ${errorText}`);
+            }
+            const diaries = await response.json();
+            console.log("Received diaries:", diaries);
+            
+            diaryDataByDate = {}; 
+            diaries.forEach(diary => {
+                // Ensure diary.date is valid before assignment
+                if (diary.date) {
+                    diaryDataByDate[diary.date] = diaryDataByDate[diary.date] || [];
+                    diaryDataByDate[diary.date].push(diary);
+                } else {
+                    console.warn("Diary item with missing date:", diary);
+                }
+            });
+            console.log("Processed diaryDataByDate:", diaryDataByDate);
+            return diaries;
+        } catch (error) {
+            console.error("Error in fetchDiaries:", error);
+            // display a user-friendly error message on the UI
+            diaryListContainer.innerHTML = `<div class="placeholder"><p>일기를 불러오는 중 오류가 발생했습니다.</p><p style="font-size: 0.8em; color: #666;">${error.message}</p></div>`;
+            return [];
+        }
+    }
+
+    function renderTimeline(dateStr) {
+        const diaries = diaryDataByDate[dateStr] || [];
+        diaryListContainer.innerHTML = '';
+        if (diaries.length === 0) {
+            diaryListContainer.innerHTML = '<div class="placeholder"><p>작성된 일기가 없습니다.</p></div>';
+            return;
+        }
+        diaries.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+        diaries.forEach(diary => {
+            const emotionInfo = emotionMap[diary.emotion] || emotionMap.default;
+            const item = document.createElement('div');
+            item.className = `timeline-item ${emotionInfo.itemClass}`;
+            item.dataset.diary = JSON.stringify(diary); // 전체 diary 객체 저장
+            const time = new Date(diary.createdAt).toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit' });
+
+            item.innerHTML = `
+                <div class="item-header">
+                    <span class="item-time">${time}</span>
+                    <div class="item-controls">
+                        <span class="item-emotion">${emotionInfo.emoji}</span>
+                        <button class="delete-diary-btn" data-diary-id="${diary.id}">삭제</button>
+                    </div>
+                </div>
+                <div class="item-content">
+                    <p>${diary.content.replace(/\n/g, '<br>')}</p>
+                </div>
+            `;
+            diaryListContainer.appendChild(item);
+        });
+    }
+
+    function updateUI(year, month) { // month is 0-indexed
+        currentYear = year;
+        currentMonth = month;
+        currentYearEl.textContent = year;
+        calendarMonthTitle.textContent = new Date(year, month).toLocaleString('en-US', { month: 'long' });
+        document.querySelectorAll('.month-item').forEach(item => {
+            item.classList.toggle('active', parseInt(item.dataset.month) === month);
+        });
+    }
+    
+    async function handleDateChange(year, month) { // month is 0-indexed
+        updateUI(year, month);
+        await updateMonthlyCounts(year); // 연도가 바뀔 때마다 카운트 업데이트
+        await fetchDiaries(year, month + 1);
+        if (fp) fp.redraw();
+    }
+
+    const parseRecs = (text) => {
+        const contents = { 수용: '', 전환: '' };
+        if (!text) return contents;
+        const regex = /#+\s*\[\s*(수용|공감|전환|환기)\s*\]([\s\S]*?)(?=(?:#+\s*\[\s*(?:수용|공감|전환|환기)\s*\])|$)/gi;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            const type = match[1].trim();
+            let content = match[2].trim();
+            if (type === '수용' || type === '공감') contents.수용 = content;
+            else if (type === '전환' || type === '환기') contents.전환 = content;
+        }
+        return contents;
+    };
+
+    const parseAndClean = (markdown) => {
+        if (!markdown) return '<p class="empty-msg">추천 항목이 없습니다.</p>';
+
+        const rawHtml = marked.parse(markdown);
+        const tempDiv = document.createElement('div');
+        tempDiv.innerHTML = rawHtml;
+
+        // 방식 1: "추천 이유"가 열 헤더인 경우 해당 열 전체 제거
+        const tables = tempDiv.querySelectorAll('table');
+        tables.forEach(table => {
+            let reasonColumnIndex = -1;
+            table.querySelectorAll('th').forEach((th, index) => {
+                if (th.textContent.trim() === '추천 이유') {
+                    reasonColumnIndex = index;
+                }
+            });
+
+            if (reasonColumnIndex !== -1) {
+                table.querySelectorAll('tr').forEach(row => {
+                    if (row.cells[reasonColumnIndex]) {
+                        row.deleteCell(reasonColumnIndex);
+                    }
+                });
+            }
+        });
+
+        // 방식 2: "추천 이유:" 텍스트가 포함된 행 제거
+        const rowsToRemove = [];
+        tempDiv.querySelectorAll('td').forEach(td => {
+            if (td.textContent.includes('추천 이유:')) {
+                const row = td.closest('tr');
+                if (row) rowsToRemove.push(row);
+            }
+        });
+        rowsToRemove.forEach(row => row.remove());
+        
+        // 카테고리 텍스트("영화", "음악", "도서")를 이모지로 변경 (첫 번째 열만)
+        const categoryEmojiMap = { '영화': '🎬', '음악': '🎵', '도서': '📚' };
+        tempDiv.querySelectorAll('tr').forEach(row => {
+            // 헤더 행이 아니고, 셀이 존재할 경우
+            if (row.cells.length > 0 && row.cells[0].tagName === 'TD') {
+                const firstCell = row.cells[0];
+                let cellHtml = firstCell.innerHTML;
+                for (const category in categoryEmojiMap) {
+                    const regex = new RegExp(`(<strong>)?${category}(</strong>)?`, "g");
+                    cellHtml = cellHtml.replace(regex, categoryEmojiMap[category]);
+                }
+                firstCell.innerHTML = cellHtml;
+            }
+        });
+
+        return tempDiv.innerHTML;
+    };
+
+    // --- Event Listeners ---
+    const detailModalOverlay = document.getElementById('diary-detail-modal-overlay');
+    const detailModalCloseBtn = document.getElementById('diary-detail-modal-close');
+
+    monthList.addEventListener('click', (e) => {
+        if (e.target.classList.contains('month-item')) {
+            const month = parseInt(e.target.dataset.month);
+            if (month !== currentMonth) fp.changeMonth(month - currentMonth);
+        }
+    });
+
+    prevYearBtn.addEventListener('click', () => fp.changeYear(fp.currentYear - 1));
+    nextYearBtn.addEventListener('click', () => fp.changeYear(fp.currentYear + 1));
+    
+    diaryListContainer.addEventListener('click', async (e) => {
+        // 삭제 버튼 로직
+        if (e.target.classList.contains('delete-diary-btn')) {
+            e.stopPropagation(); // 이벤트 버블링 방지
+            const diaryId = e.target.dataset.diaryId;
+            if (!diaryId || !confirm('정말로 이 일기를 삭제하시겠습니까?')) {
+                return;
+            }
+
+            try {
+                const response = await fetch(`/diary/delete/${diaryId}`, {
+                    method: 'DELETE',
+                });
+
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    throw new Error(errorData.error || '삭제에 실패했습니다.');
+                }
+
+                // 삭제 성공 후 UI 업데이트
+                const selectedDate = fp.selectedDates[0];
+                await handleDateChange(selectedDate.getFullYear(), selectedDate.getMonth());
+                renderTimeline(flatpickr.formatDate(selectedDate, "Y-m-d"));
+
+            } catch (error) {
+                console.error('삭제 중 오류 발생:', error);
+                alert(error.message);
+            }
+            return; 
+        }
+        
+        // 상세 모달 로직
+        const timelineItem = e.target.closest('.timeline-item');
+        if (timelineItem && timelineItem.dataset.diary) {
+            try {
+                const diary = JSON.parse(timelineItem.dataset.diary);
+                openDiaryDetailModal(diary);
+            } catch (jsonError) {
+                console.error("Failed to parse diary data from dataset:", jsonError);
+            }
+        }
+    });
+
+    function openDiaryDetailModal(diary) {
+        const modalTitle = document.getElementById('diary-detail-title');
+        const modalBody = document.getElementById('diary-detail-body');
+        
+        modalTitle.innerHTML = ''; // 제목 제거
+
+        let bodyHtml = `
+            <div class="diary-content-section">
+                <h3>나의 기록</h3>
+                <p>${diary.content.replace(/\n/g, '<br>')}</p>
+            </div>
+        `;
+
+        if (diary.recommendation) {
+            const sections = parseRecs(diary.recommendation);
+            if (sections.수용) {
+                bodyHtml += `
+                    <div class="diary-content-section">
+                        <h3>수용</h3>
+                        ${parseAndClean(sections.수용)}
+                    </div>
+                `;
+            }
+            if (sections.전환) {
+                bodyHtml += `
+                    <div class="diary-content-section">
+                        <h3>전환</h3>
+                        ${parseAndClean(sections.전환)}
+                    </div>
+                `;
+            }
+        }
+        
+        modalBody.innerHTML = bodyHtml;
+        detailModalOverlay.style.display = 'flex';
+    }
+
+    function closeDiaryDetailModal() {
+        detailModalOverlay.style.display = 'none';
+    }
+
+    detailModalCloseBtn.addEventListener('click', closeDiaryDetailModal);
+    detailModalOverlay.addEventListener('click', (e) => {
+        if (e.target === detailModalOverlay) {
+            closeDiaryDetailModal();
+        }
+    });
+
+    function initializeCalendar() {
+        fp = flatpickr("#calendar", {
+            inline: true,
+            dateFormat: "Y-m-d",
+            locale: "en",
+            onReady: async (selectedDates, dateStr, instance) => {
+                const today = new Date();
+                await handleDateChange(today.getFullYear(), today.getMonth());
+                instance.setDate(today, true);
+            },
+            onChange: (selectedDates, dateStr, instance) => {
+                if (selectedDates.length > 0) renderTimeline(dateStr);
+            },
+            onMonthChange: async (selectedDates, dateStr, instance) => {
+                await handleDateChange(instance.currentYear, instance.currentMonth);
+            },
+            onYearChange: async (selectedDates, dateStr, instance) => {
+                await handleDateChange(instance.currentYear, instance.currentMonth);
+            },
+            onDayCreate: (dObj, dStr, fp, dayElem) => {
+                // 날짜 숫자를 span으로 감싸서 z-index 제어
+                dayElem.innerHTML = `<span class="flatpickr-day-num">${dayElem.innerHTML}</span>`;
+
+                const date = flatpickr.formatDate(dayElem.dateObj, "Y-m-d");
+                const diariesForDay = diaryDataByDate[date];
+                if (diariesForDay && diariesForDay.length > 0) {
+                    const latestDiary = diariesForDay[diariesForDay.length - 1];
+                    const emotionInfo = emotionMap[latestDiary.emotion] || emotionMap.default;
+                    
+                    // 날짜 셀에 직접 배경색 클래스를 추가 (가상요소 ::before가 �� 클래스를 사용)
+                    dayElem.classList.add('has-diary', emotionInfo.bgClass);
+                }
+            }
+        });
+    }
+
+    // --- Initial Load ---
+    initializeCalendar();
+});

src/templates/static/js/macros_rec_tabs.js

@@ -0,0 +1,13 @@
+document.addEventListener('click', function(event) {
+    if (event.target.classList.contains('rec-tab-btn')) {
+        const tabId = event.target.dataset.tab;
+        const tabsContainer = event.target.closest('.rec-tabs');
+        const contentContainer = tabsContainer.parentElement;
+
+        tabsContainer.querySelectorAll('.rec-tab-btn').forEach(btn => btn.classList.remove('active'));
+        event.target.classList.add('active');
+
+        contentContainer.querySelectorAll('.rec-content').forEach(content => content.classList.remove('active'));
+        document.getElementById(tabId).classList.add('active');
+    }
+});

src/templates/static/js/main_logic.js

@@ -0,0 +1,311 @@
+document.addEventListener('DOMContentLoaded', function () {
+    // --- DOM 요소 가져오기 ---
+    const diaryTextarea = document.getElementById('diary');
+    const submitBtn = document.getElementById('submit-btn');
+    const resultContainer = document.getElementById('result-container');
+    const resultDiv = document.getElementById('result');
+    const saveStatus = document.getElementById('save-status');
+    const saveBtnContainer = document.getElementById('save-action-container');
+    const saveDiaryBtn = document.getElementById('final-save-btn');
+    const diaryBook = document.querySelector('.diary-book');
+    const leftPage = diaryBook.querySelector('.left-page');
+    const rightPage = diaryBook.querySelector('.right-page');
+
+
+    // --- 상태 변수 ---
+    let currentEmotion = null;
+    let currentCandidates = [];
+    let progressInterval = null;
+    let diaryText = ''; // 일기 내용을 저장할 변수
+
+    // --- [유틸리티] 추천 내용 파싱 함수 ---
+    function parseRecommendation(text) {
+        const contents = { acceptance: '', diversion: '' };
+        if (!text) return contents;
+        const regex = /#+\s*\[\s*(수용|전환)\s*\]([\s\S]*?)(?=(?:#+\s*\[\s*(?:수용|전환)\s*\])|$)/gi;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            const type = match[1].trim();
+            const content = match[2].trim();
+            if (type === '수용') contents.acceptance = content;
+            else if (type === '전환') contents.diversion = content;
+        }
+        return contents;
+    }
+
+    // --- [유틸리티] 로딩 바 표시 ---
+    function showLoader(message) {
+        resultDiv.innerHTML = `
+            <div style="text-align: center; padding: 20px;">
+                <p class="loading-text" style="margin-bottom: 10px; color: #666;">${message}</p>
+                <div class="progress-bar-container" style="width: 100%; background-color: #f0f0f0; border-radius: 10px; overflow: hidden; height: 8px;">
+                    <div class="progress-bar" style="width: 0%; height: 100%; background-color: var(--primary-color, #6598e5); transition: width 0.1s;"></div>
+                </div>
+            </div>
+        `;
+        if (progressInterval) clearInterval(progressInterval);
+        const bar = resultDiv.querySelector('.progress-bar');
+        let width = 0;
+        progressInterval = setInterval(() => {
+            if (width < 95) {
+                width += 1; 
+                if(bar) bar.style.width = width + '%';
+            }
+        }, 50);
+    }
+
+    // --- [유틸리티] 로딩 바 중지 ---
+    function stopLoader() {
+        if (progressInterval) {
+            clearInterval(progressInterval);
+            progressInterval = null;
+        }
+        const bar = resultDiv.querySelector('.progress-bar');
+        if (bar) bar.style.width = '100%';
+    }
+    
+    // --- [핵심] 결과 화면 렌더링 함수 ---
+    function renderFullResult(data) {
+        stopLoader();
+        const recommendation = data.recommendation || '';
+        const candidates = data.candidates || [];
+        if (!currentEmotion && candidates.length > 0) {
+            currentEmotion = candidates[0].emotion;
+        }
+        const { acceptance, diversion } = parseRecommendation(recommendation);
+        let chipsHTML = '';
+        const showChips = (data.top_score < 0.8) || (candidates.length > 0); 
+        if (showChips) {
+             chipsHTML = `<div class="emotion-chips" style="display: flex; gap: 10px; justify-content: center; margin-bottom: 20px;">`;
+             candidates.forEach(candidate => {
+                const isActive = candidate.emotion === currentEmotion;
+                chipsHTML += `
+                    <button class="emotion-chip ${isActive ? 'active' : ''}" data-emotion="${candidate.emotion}">
+                        ${candidate.emoji} ${candidate.emotion} 
+                        <span class="score-badge">${Math.round(candidate.score*100)}%</span>
+                    </button>
+                `;
+             });
+             chipsHTML += `</div>`;
+        }
+        const contentHTML = `
+            ${chipsHTML}
+            <div class="rec-tabs">
+                <button class="rec-tab-btn active" data-tab="acceptance">수용</button>
+                <button class="rec-tab-btn" data-tab="diversion">전환</button>
+            </div>
+            <div id="rec-acceptance" class="rec-content active">
+                ${marked.parse(acceptance || '추천 내용을 불러오지 못했습니다.')}
+            </div>
+            <div id="rec-diversion" class="rec-content">
+                ${marked.parse(diversion || '추천 내용을 불러오지 못했습니다.')}
+            </div>
+        `;
+        resultDiv.innerHTML = contentHTML;
+        if (saveBtnContainer) {
+            saveBtnContainer.style.display = 'flex';
+        }
+        resultDiv.querySelectorAll('.emotion-chip').forEach(chip => {
+            chip.addEventListener('click', handleChipClick);
+        });
+        resultDiv.querySelectorAll('.rec-tab-btn').forEach(button => {
+            button.addEventListener('click', () => {
+                const tab = button.dataset.tab;
+                resultDiv.querySelectorAll('.rec-tab-btn').forEach(btn => btn.classList.remove('active'));
+                button.classList.add('active');
+                resultDiv.querySelectorAll('.rec-content').forEach(content => content.classList.remove('active'));
+                resultDiv.querySelector(`#rec-${tab}`).classList.add('active');
+            });
+        });
+    }
+    
+    // --- [이벤트 핸들러] ---
+    function updateButtonState() {
+        if(diaryTextarea && submitBtn) {
+            submitBtn.disabled = diaryTextarea.value.trim() === '';
+        }
+    }
+    
+    async function handleChipClick(event) {
+        const selectedChip = event.currentTarget;
+        const selectedEmotion = selectedChip.dataset.emotion;
+        if (currentEmotion === selectedEmotion) return;
+        currentEmotion = selectedEmotion;
+        resultDiv.querySelectorAll('.emotion-chip').forEach(chip => {
+            chip.classList.toggle('active', chip.dataset.emotion === selectedEmotion);
+        });
+        showLoader('새로운 추천을 생성하는 중입니다...');
+        try {
+            const response = await fetch('/api/recommend', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ 
+                    diary: diaryTextarea.value.trim(), 
+                    emotion: selectedEmotion 
+                })
+            });
+            const data = await response.json();
+            if (data.error) {
+                stopLoader();
+                resultDiv.innerHTML = `<p style="color: red;">오류: ${data.error}</p>`;
+            } else {
+                renderFullResult({
+                    recommendation: data.recommendation,
+                    candidates: currentCandidates, 
+                    top_score: 0
+                });
+            }
+        } catch (error) {
+            console.error('Error:', error);
+            stopLoader();
+            resultDiv.innerHTML = '<p style="color: red;">서버 오류가 발생했습니다.</p>';
+        }
+    }
+
+    async function handleDiarySubmission() {
+        diaryText = diaryTextarea.value.trim();
+        if (!diaryText) return;
+        submitBtn.disabled = true;
+        submitBtn.textContent = '분석 중...';
+        if(saveBtnContainer) saveBtnContainer.style.display = 'none'; 
+        saveStatus.textContent = '';
+        showLoader('감정을 분석하고 추천을 생성하는 중입니다...');
+        try {
+            const response = await fetch('/api/predict', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ diary: diaryText })
+            });
+            const data = await response.json();
+            if (data.error) {
+                stopLoader();
+                resultDiv.innerHTML = `<p style="color: red;">오류: ${data.error}</p>`;
+                return;
+            }
+            currentEmotion = data.top_emotion;
+            currentCandidates = data.candidates;
+            renderFullResult(data);
+        } catch (error) {
+            console.error('Error:', error);
+            stopLoader();
+            resultDiv.innerHTML = '<p style="color: red;">처리 중 서버 오류가 발생했습니다.</p>';
+        } finally {
+            submitBtn.disabled = false;
+            submitBtn.textContent = '다시 분석하기';
+        }
+    }
+
+    const emotionColors = {
+        '기쁨': '#FFD700', '슬픔': '#4682B4', '분노': '#B22222',
+        '불안': '#8A2BE2', '당황': '#FF8C00', '상처': '#2E8B57'
+    };
+
+    function playFullAnimation(element, orbColor, duration) {
+        const keyframes = [
+            { top: 'calc(50vh - 25px)', left: 'calc(50vw - 25px)', transform: 'scale(1)', offset: 0 },
+            { top: 'calc(100vh - 80px)', left: 'calc(50vw - 25px)', transform: 'scale(1.2, 0.8)', offset: 0.1 },
+            { top: '60vh', left: '58vw', transform: 'scale(1, 1)', offset: 0.25 },
+            { top: 'calc(100vh - 80px)', left: '68vw', transform: 'scale(1.15, 0.85)', offset: 0.40 },
+            { top: '75vh', left: '76vw', transform: 'scale(1, 1)', offset: 0.55 },
+            { top: 'calc(100vh - 80px)', left: '83vw', transform: 'scale(1.1, 0.9)', offset: 0.65 },
+            { top: '85vh', left: '89vw', transform: 'scale(1, 1)', offset: 0.75 },
+            { top: 'calc(100vh - 80px)', left: '94vw', transform: 'scale(1.05, 0.95)', offset: 0.85 },
+            { top: '90vh', left: '96.5vw', transform: 'scale(1, 1)', offset: 0.92 },
+            { top: 'calc(100vh - 80px)', left: '98vw', transform: 'scale(1.02, 0.98)', offset: 0.96 },
+            { top: 'calc(100vh - 80px)', left: 'calc(100vw - 80px)', transform: 'scale(1, 1)', offset: 1 }
+        ];
+        const options = { duration: duration, easing: 'ease-in-out', fill: 'forwards' };
+        return element.animate(keyframes, options);
+    }
+
+    async function handleDiarySave() {
+        if (!diaryBook) return;
+        if (document.querySelector('.js-animating')) return;
+
+        if (saveDiaryBtn) saveDiaryBtn.disabled = true;
+        saveStatus.textContent = '기억을 저장하는 중...';
+
+        const formData = new FormData();
+        formData.append('diary', diaryText);
+        formData.append('emotion', currentEmotion);
+        fetch('/diary/save', {
+            method: 'POST',
+            body: formData
+        }).then(response => response.json()).then(data => {
+            if (data.error) {
+                 saveStatus.innerHTML = `<span style="color: red;">저장 실패: ${data.error}</span>`;
+            }
+        }).catch(err => {
+            saveStatus.innerHTML = `<span style="color: red;">저장 중 오류 발생</span>`;
+            console.error(err);
+        });
+
+        const bookFoldDuration = 1500;
+        const bounceDuration = 5000;
+        const emotionKey = (currentEmotion || '기쁨').split(' ')[0];
+        const orbColor = emotionColors[emotionKey] || '#a1c4fd';
+
+        const animElement = document.createElement('div');
+        animElement.classList.add('js-animating-orb');
+        animElement.style.position = 'fixed';
+        animElement.style.zIndex = '9999';
+        animElement.style.width = '50px';
+        animElement.style.height = '50px';
+        animElement.style.borderRadius = '50%';
+        animElement.style.background = `radial-gradient(circle at 30% 30%, rgba(255,255,255,0.5), ${orbColor} 80%)`;
+        animElement.style.boxShadow = `0 0 35px ${orbColor}, inset 3px 3px 8px rgba(0,0,0,0.4), inset -3px -3px 8px rgba(255,255,255,0.7)`;
+        animElement.style.top = 'calc(50vh - 25px)';
+        animElement.style.left = 'calc(50vw - 25px)';
+        animElement.style.opacity = '0';
+        animElement.style.transform = 'scale(0)';
+        document.body.appendChild(animElement);
+
+        diaryBook.classList.add('js-animating');
+        const bookRect = diaryBook.getBoundingClientRect();
+        const translateX = (window.innerWidth / 2) - (bookRect.left + bookRect.width / 2);
+        const translateY = (window.innerHeight / 2) - (bookRect.top + bookRect.height / 2);
+
+        const bookToOrbKeyframes = [
+            { transform: 'translate(0, 0) scale(1)', opacity: 1, backgroundColor: '#fdfbf7', borderRadius: '20px' },
+            { backgroundColor: orbColor, borderRadius: '50%', offset: 0.7 },
+            { transform: `translate(${translateX}px, ${translateY}px) scale(0)`, opacity: 0, backgroundColor: orbColor, borderRadius: '50%' }
+        ];
+        const animOptions = { duration: bookFoldDuration, easing: 'ease-in-out', fill: 'forwards' };
+        const bookAnimation = diaryBook.animate(bookToOrbKeyframes, animOptions);
+
+        const orbAppearKeyframes = [
+            { transform: 'scale(0)', opacity: 0 },
+            { transform: 'scale(1)', opacity: 1, offset: 0.8 },
+            { transform: 'scale(1)', opacity: 1 }
+        ];
+        animElement.animate(orbAppearKeyframes, { duration: bookFoldDuration, easing: 'ease-out', fill: 'forwards' });
+
+        bookAnimation.onfinish = () => {
+            diaryBook.style.visibility = 'hidden';
+            const bounceAnimation = playFullAnimation(animElement, orbColor, bounceDuration);
+            bounceAnimation.onfinish = () => {
+                if (document.body.contains(animElement)) document.body.removeChild(animElement);
+                window.location.href = '/my_diary';
+            };
+        };
+    }
+
+    // --- 날짜 표시 업데이트 ---
+    function updateDateLabel() {
+        const dateLabel = document.querySelector('.date-label');
+        if (dateLabel) {
+            const today = new Date();
+            const options = { year: 'numeric', month: 'long', day: 'numeric' };
+            const formattedDate = today.toLocaleDateString('ko-KR', options);
+            dateLabel.textContent = formattedDate;
+        }
+    }
+
+    // --- 초기화 실행 ---
+    if(diaryTextarea) diaryTextarea.addEventListener('input', updateButtonState);
+    if(submitBtn) submitBtn.addEventListener('click', handleDiarySubmission);
+    if(saveDiaryBtn) saveDiaryBtn.addEventListener('click', handleDiarySave);
+
+    if(diaryTextarea) updateButtonState();
+    updateDateLabel();
+});

src/templates/static/js/main_onboarding.js

@@ -0,0 +1,91 @@
+// Onboarding script
+document.addEventListener('DOMContentLoaded', function() {
+    const overlay = document.getElementById('onboarding-overlay');
+    const nextBtn = document.getElementById('onboarding-next');
+    const prevBtn = document.getElementById('onboarding-prev');
+    const closeBtn = document.getElementById('onboarding-close');
+    const dots = document.querySelectorAll('.onboarding-dot');
+    const slides = document.querySelectorAll('.onboarding-slide');
+    const nicknameInput = document.getElementById('onboarding-nickname-input');
+    let currentSlide = 1;
+
+    const onboardingComplete = localStorage.getItem('onboardingComplete');
+    if (onboardingComplete !== 'true') {
+        overlay.classList.add('active');
+    }
+
+    function showSlide(slideNumber) {
+        slides.forEach(slide => slide.classList.remove('active'));
+        dots.forEach(dot => dot.classList.remove('active'));
+
+        document.getElementById(`slide${slideNumber}`).classList.add('active');
+        document.querySelector(`.onboarding-dot[data-slide='${slideNumber}']`).classList.add('active');
+        currentSlide = slideNumber;
+
+        // Update button visibility and text
+        if (currentSlide === 1) {
+            prevBtn.style.display = 'none';
+        } else {
+            prevBtn.style.display = 'inline-block';
+        }
+
+        if (currentSlide === slides.length) {
+            nextBtn.textContent = '시작하기';
+        } else {
+            nextBtn.textContent = '다음';
+        }
+    }
+
+    nextBtn.addEventListener('click', async () => {
+        if (currentSlide < slides.length) {
+            showSlide(currentSlide + 1);
+        } else { // Last slide (nickname setting)
+            const nickname = nicknameInput.value.trim();
+            if (nickname) {
+                try {
+                    const response = await fetch('/update_nickname', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/x-www-form-urlencoded',
+                        },
+                        body: `nickname=${encodeURIComponent(nickname)}`,
+                    });
+                    if (!response.ok) {
+                        throw new Error('Failed to update nickname');
+                    }
+                    // Optionally, update session storage or display a success message
+                    console.log('Nickname updated successfully');
+                } catch (error) {
+                    console.error('Error updating nickname:', error);
+                    // Handle error, e.g., show a message to the user
+                }
+            }
+            localStorage.setItem('onboardingComplete', 'true');
+            closeOnboarding();
+        }
+    });
+
+    prevBtn.addEventListener('click', () => {
+        if (currentSlide > 1) {
+            showSlide(currentSlide - 1);
+        }
+    });
+
+    closeBtn.addEventListener('click', () => {
+        localStorage.setItem('onboardingComplete', 'true');
+        closeOnboarding();
+    });
+
+    dots.forEach(dot => {
+        dot.addEventListener('click', (e) => {
+            const slideNumber = parseInt(e.target.dataset.slide);
+            showSlide(slideNumber);
+        });
+    });
+
+    function closeOnboarding() {
+        overlay.classList.remove('active');
+    }
+
+    showSlide(currentSlide); // Initialize first slide
+});

src/templates/static/js/main_theme.js

@@ -0,0 +1,88 @@
+// 테마 변경 스크립트
+document.addEventListener('DOMContentLoaded', function() {
+    const body = document.body;
+    const root = document.documentElement;
+    const themePalette = document.querySelector('.theme-palette');
+    const themeWrappers = document.querySelectorAll('.theme-option-wrapper');
+
+    // --- 테마 설정 ---
+    const themes = {
+        // 그라디언트 테마
+        default: { bg: 'linear-gradient(135deg, #ece9f7, #cacae0)', primary: '#6598e5' },
+        sunset: { bg: 'linear-gradient(135deg, #ff7e5f, #feb47b)', primary: '#e5533b' },
+        forest: { bg: 'linear-gradient(135deg, #5a3f37, #2c7744)', primary: '#92b57a' },
+        sky: { bg: 'linear-gradient(135deg, #a1c4fd, #c2e9fb)', primary: '#6a89cc' },
+        night: { bg: 'linear-gradient(135deg, #0f2027, #203a43, #2c5364)', primary: '#a3b1c6' },
+        sea: { bg: 'linear-gradient(135deg, #2c7744, #6598e5)', primary: '#92b57a' },
+
+        // 단색 테마
+        current: { bg: 'linear-gradient(135deg, #ece9f7, #cacae0)', primary: '#6598e5' },
+        blue: { bg: 'linear-gradient(135deg, #a1c4fd, #c2e9fb)', primary: '#6a89cc' }, // 하늘 테마 색상으로 변경
+        lightyellow: { bg: '#fff9e6', primary: '#d4a237' },
+    };
+
+    function applyTheme(theme) {
+        body.style.background = theme.bg;
+        root.style.setProperty('--primary-color', theme.primary);
+    }
+
+    function saveTheme(themeName, themeData) {
+        localStorage.setItem('themeName', themeName);
+        if (themeName.startsWith('image-')) {
+            localStorage.setItem('themeIsImage', 'true');
+            localStorage.setItem('themeValue', themeData.bg);
+        }
+        else {
+            localStorage.setItem('themeIsImage', 'false');
+            localStorage.setItem('themeValue', themeName);
+        }
+    }
+
+    // --- 이벤트 리스너 ---
+    themePalette.addEventListener('click', (e) => {
+        const target = e.target;
+        const wrapper = target.closest('.theme-option-wrapper');
+
+        // 메인 버튼(.theme-btn) 클릭 시 메뉴 토글
+        if (target.classList.contains('theme-btn')) {
+            e.stopPropagation();
+            themeWrappers.forEach(w => {
+                if (w !== wrapper) w.classList.remove('active');
+            });
+            wrapper.classList.toggle('active');
+            return; // 메인 버튼 클릭 시 테마 적용 로직을 실행하지 않음
+        }
+
+        const subOptions = target.closest('.sub-options');
+        if (subOptions) {
+            // --- 테마 적용 로직 ---
+            let themeName, themeData;
+
+            // 이미지 버튼 클릭 시
+            if (target.tagName === 'IMG' && target.dataset.themeBg) {
+                themeName = 'image-' + target.dataset.themeBg;
+                themeData = { bg: target.dataset.themeBg };
+                body.style.background = `url(${themeData.bg}) no-repeat center center / cover`;
+                saveTheme(themeName, themeData);
+            }
+            // 색상 버튼 (서브) 클릭 시
+            else if (target.classList.contains('sub-option-btn') && target.dataset.color) {
+                themeName = target.dataset.color;
+                if (themes[themeName]) {
+                    themeData = themes[themeName];
+                    applyTheme(themeData);
+                    saveTheme(themeName, themeData);
+                }
+            }
+            // 테마 적용 후 모든 메뉴 닫기
+            themeWrappers.forEach(w => w.classList.remove('active'));
+        }
+    });
+
+    // 팔레트 바깥 영역 클릭 시 모든 메뉴 닫기
+    document.addEventListener('click', (e) => {
+        if (!themePalette.contains(e.target)) {
+            themeWrappers.forEach(w => w.classList.remove('active'));
+        }
+    });
+});

src/templates/static/js/script.js

@@ -0,0 +1,27 @@
+document.addEventListener('DOMContentLoaded', function() {
+    // --- 매직 내비게이션 바 동작 ---
+    const marker = document.querySelector('.nav-marker');
+    const navItems = document.querySelectorAll('.nav-item a');
+    const navList = document.querySelector('.navbar-menu');
+
+    function moveMarker(e) {
+        const item = e.target.closest('li'); // li 요소 기준
+        if (item && marker) {
+            marker.style.width = (item.offsetWidth - 10) + 'px';
+            marker.style.left = (item.offsetLeft + 12) + 'px';
+            marker.style.opacity = '1';
+        }
+    }
+
+    // 각 메뉴에 마우스 올리면 마커 이동
+    navItems.forEach(link => {
+        link.addEventListener('mouseenter', moveMarker);
+    });
+
+    // 메뉴 밖으로 나가면 마커 숨기기 (선택사항)
+    if (navList) {
+        navList.addEventListener('mouseleave', () => {
+            if(marker) marker.style.opacity = '0';
+        });
+    }
+});