내 컴퓨터에서 24시간 도는 유튜브 제작 에이전트 만들기 - 1주차: 뼈대 세우기

`main.py` — 서버 핵심 (요청을 받아 저장/조회)
```python
from typing import List
from fastapi import FastAPI, HTTPException
import store
from models import Idea, IdeaCreate, VideoProject, VideoCreate, OutputsUpdate

app = FastAPI(title="유튜브 콘텐츠 제작 에이전트 API", version="0.1.0 (week1)")

@app.get("/")
def health():
    return {"status": "ok", "service": "youtube-agent", "week": 1}

# 아이디어 인박스
@app.post("/ideas", response_model=Idea)
def create_idea(body: IdeaCreate):
    return store.add_idea(body.text)

@app.get("/ideas", response_model=List[Idea])
def get_ideas():
    return store.list_ideas()

# 영상 프로젝트
@app.post("/videos", response_model=VideoProject)
def create_video(body: VideoCreate):
    return store.add_video(body.idea)

@app.get("/videos", response_model=List[VideoProject])
def get_videos():
    return store.list_videos()

@app.get("/videos/{video_id}", response_model=VideoProject)
def get_one_video(video_id: str):
    video = store.get_video(video_id)
    if not video:
        raise HTTPException(status_code=404, detail="영상 프로젝트를 찾을 수 없습니다.")
    return video

@app.put("/videos/{video_id}/outputs", response_model=VideoProject)
def put_outputs(video_id: str, body: OutputsUpdate):
    patch = body.model_dump(exclude_unset=True)
    video = store.update_outputs(video_id, patch)
    if not video:
        raise HTTPException(status_code=404, detail="영상 프로젝트를 찾을 수 없습니다.")
    return video
```

**`models.py`** — 저장할 정보의 '양식' 정의
```python
from datetime import datetime
from typing import Optional, List
from pydantic import BaseModel, Field
import uuid

def _now() -> str:
    return datetime.now().isoformat(timespec="seconds")

def _new_id() -> str:
    return uuid.uuid4().hex[:8]

# 아이디어 인박스
class Idea(BaseModel):
    id: str = Field(default_factory=_new_id)
    text: str
    status: str = "queued"        # queued(대기) → drafted(초안생성됨)
    created_at: str = Field(default_factory=_now)

class IdeaCreate(BaseModel):
    text: str

# 영상 산출물(5종)
class VideoOutputs(BaseModel):
    flow: Optional[str] = None            # ① 전체 영상 흐름
    script: Optional[str] = None          # ② 대본
    slides_md: Optional[str] = None       # ③ 장표(마크다운)
    thumbnail_copy: Optional[str] = None  # ④ 썸네일 문구/시안
    title: Optional[str] = None           # ⑤ 제목
    description: Optional[str] = None      # ⑤ 본문(설명)
    tags: List[str] = Field(default_factory=list)

class VideoProject(BaseModel):
    id: str = Field(default_factory=_new_id)
    idea: str
    status: str = "queued"                # queued → drafting → ready
    outputs: VideoOutputs = Field(default_factory=VideoOutputs)
    created_at: str = Field(default_factory=_now)
    updated_at: str = Field(default_factory=_now)

class VideoCreate(BaseModel):
    idea: str

class OutputsUpdate(BaseModel):
    flow: Optional[str] = None
    script: Optional[str] = None
    slides_md: Optional[str] = None
    thumbnail_copy: Optional[str] = None
    title: Optional[str] = None
    description: Optional[str] = None
    tags: Optional[List[str]] = None
    status: Optional[str] = None
```

**`store.py`** — 데이터를 실제 파일(JSON)에 저장/조회
```python
import json
import threading
from pathlib import Path
from typing import Optional, List
from models import Idea, VideoProject, _now

DATA_FILE = Path(__file__).parent / "data" / "db.json"
_lock = threading.Lock()

def _read() -> dict:
    if not DATA_FILE.exists():
        return {"ideas": [], "videos": []}
    return json.loads(DATA_FILE.read_text(encoding="utf-8"))

def _write(db: dict) -> None:
    DATA_FILE.parent.mkdir(parents=True, exist_ok=True)
    DATA_FILE.write_text(json.dumps(db, ensure_ascii=False, indent=2), encoding="utf-8")

# 아이디어 인박스
def add_idea(text: str) -> Idea:
    with _lock:
        db = _read()
        idea = Idea(text=text)
        db["ideas"].append(idea.model_dump())
        _write(db)
        return idea

def list_ideas() -> List[Idea]:
    return [Idea(**i) for i in _read()["ideas"]]

# 영상 프로젝트
def add_video(idea: str) -> VideoProject:
    with _lock:
        db = _read()
        video = VideoProject(idea=idea)
        db["videos"].append(video.model_dump())
        _write(db)
        return video

def list_videos() -> List[VideoProject]:
    return [VideoProject(**v) for v in _read()["videos"]]

def get_video(video_id: str) -> Optional[VideoProject]:
    for v in _read()["videos"]:
        if v["id"] == video_id:
            return VideoProject(**v)
    return None

def update_outputs(video_id: str, patch: dict) -> Optional[VideoProject]:
    with _lock:
        db = _read()
        for v in db["videos"]:
            if v["id"] == video_id:
                status = patch.pop("status", None)
                if status is not None:
                    v["status"] = status
                for key, value in patch.items():
                    v["outputs"][key] = value
                v["updated_at"] = _now()
                _write(db)
                return VideoProject(**v)
    return None
```