@ripla/godd-mcp 0.1.2-beta-20260312091403

package/notes-api/app/services/pr_chain.py

@@ -0,0 +1,225 @@
+"""PR chain: save to branch, create PR, discard."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from sqlalchemy import and_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models import NotesEditingSession, NotesUser
+from app.services.business_date import get_business_date
+from app.services.github_pr import (
+    close_pr,
+    commit_file,
+    create_branch,
+    create_pr,
+    delete_branch,
+    find_open_auto_prs,
+    get_branch_sha,
+)
+
+
+async def save_to_working_branch(
+    db: AsyncSession,
+    file_path: str,
+    content: str,
+    message: str,
+    existing_sha: str | None,
+    user_info: dict,
+    config: dict,
+) -> dict:
+    """Save file to user's business date branch."""
+    from app.models import NotesAuditLog
+    from app.services.audit import audit_log
+
+    business_date = await get_business_date(db)
+    branch_name = f"docs/{user_info['username']}/{business_date}"
+
+    result = await db.execute(
+        select(NotesEditingSession)
+        .where(
+            and_(
+                NotesEditingSession.user_id == UUID(user_info["id"]),
+                NotesEditingSession.business_date == business_date,
+                NotesEditingSession.status == "active",
+            )
+        )
+        .limit(1)
+    )
+    session = result.scalar_one_or_none()
+    if not session:
+        base_sha = await get_branch_sha(config["branch"], config)
+        await create_branch(branch_name, base_sha, config)
+        session = NotesEditingSession(
+            user_id=UUID(user_info["id"]),
+            branch_name=branch_name,
+            business_date=business_date,
+            status="active",
+            commit_count=0,
+            changed_files=[],
+        )
+        db.add(session)
+        await db.flush()
+        await db.refresh(session)
+
+    result = await commit_file(branch_name, file_path, content, message, existing_sha, config)
+    session.commit_count = (session.commit_count or 0) + 1
+    changed = session.changed_files or []
+    if file_path not in changed:
+        session.changed_files = changed + [file_path]
+    await db.flush()
+
+    await audit_log(db, UUID(user_info["id"]), "save", detail={"filePath": file_path, "branch": branch_name})
+
+    return {"branch": branch_name, "sha": result["sha"], "commitCount": session.commit_count}
+
+
+async def create_ready_pr(db: AsyncSession, user_id: UUID, config: dict) -> dict:
+    """Create PR from user's business date branch."""
+    from app.services.audit import audit_log
+    from app.services.business_date import get_business_date
+
+    business_date = await get_business_date(db)
+    result = await db.execute(
+        select(NotesEditingSession)
+        .where(
+            and_(
+                NotesEditingSession.user_id == user_id,
+                NotesEditingSession.business_date == business_date,
+                NotesEditingSession.status == "active",
+            )
+        )
+        .limit(1)
+    )
+    session = result.scalar_one_or_none()
+    if not session:
+        raise ValueError("No active session found for today")
+
+    if session.pr_number:
+        prs = await find_open_auto_prs(config)
+        for p in prs:
+            if p["number"] == session.pr_number:
+                return p
+
+    user_result = await db.execute(select(NotesUser).where(NotesUser.id == user_id))
+    user = user_result.scalar_one_or_none()
+    display_name = user.display_name if user else "Unknown"
+    username = user.username if user else "unknown"
+    changed_files = session.changed_files or []
+    body = "\n".join(
+        [
+            "## ripla Notes 自動生成 PR",
+            "",
+            f"- **作成者**: {display_name} (@{username})",
+            f"- **営業日**: {business_date}",
+            f"- **ブランチ**: `{session.branch_name}`",
+            f"- **コミット数**: {session.commit_count}",
+            "",
+            "### 変更ファイル",
+            *[f"- `{f}`" for f in changed_files],
+        ]
+    )
+    pr = await create_pr(
+        f"[docs] {display_name} のドキュメント更新 ({business_date})",
+        session.branch_name,
+        config["branch"],
+        body,
+        ["docs-auto", f"author:{username}"],
+        config,
+    )
+    session.pr_number = pr["number"]
+    session.pr_url = pr.get("html_url", "")
+    session.status = "pr_created"
+    await db.flush()
+    await audit_log(db, user_id, "pr_create", detail={"prNumber": pr["number"], "branch": session.branch_name})
+    return pr
+
+
+async def discard_changes(db: AsyncSession, user_id: UUID, config: dict) -> None:
+    """Discard changes: close PR, delete branch."""
+    from app.services.business_date import get_business_date
+
+    business_date = await get_business_date(db)
+    result = await db.execute(
+        select(NotesEditingSession)
+        .where(
+            and_(
+                NotesEditingSession.user_id == user_id,
+                NotesEditingSession.business_date == business_date,
+            )
+        )
+        .limit(1)
+    )
+    session = result.scalar_one_or_none()
+    if not session:
+        raise ValueError("No session found for today")
+    if session.pr_number:
+        await close_pr(session.pr_number, config)
+    await delete_branch(session.branch_name, config)
+    session.status = "discarded"
+    await db.flush()
+
+
+async def get_session_for_user(db: AsyncSession, user_id: UUID) -> dict | None:
+    """Get active session for user + business date."""
+    from app.services.business_date import get_business_date
+
+    business_date = await get_business_date(db)
+    result = await db.execute(
+        select(NotesEditingSession)
+        .where(
+            and_(
+                NotesEditingSession.user_id == user_id,
+                NotesEditingSession.business_date == business_date,
+                NotesEditingSession.status == "active",
+            )
+        )
+        .limit(1)
+    )
+    session = result.scalar_one_or_none()
+    if not session:
+        return None
+    return {
+        "id": str(session.id),
+        "branchName": session.branch_name,
+        "prNumber": session.pr_number,
+        "prUrl": session.pr_url,
+        "commitCount": session.commit_count,
+        "businessDate": session.business_date,
+        "status": session.status,
+        "changedFiles": session.changed_files or [],
+        "createdAt": session.created_at.isoformat() if session.created_at else None,
+        "updatedAt": session.updated_at.isoformat() if session.updated_at else None,
+    }
+
+
+async def get_all_active_sessions(db: AsyncSession) -> list:
+    """Get all active sessions with user info."""
+    from app.services.business_date import get_business_date
+
+    business_date = await get_business_date(db)
+    result = await db.execute(
+        select(NotesEditingSession, NotesUser.username, NotesUser.display_name)
+        .join(NotesUser, NotesEditingSession.user_id == NotesUser.id)
+        .where(NotesEditingSession.status == "active")
+        .order_by(NotesEditingSession.updated_at)
+    )
+    rows = result.all()
+    return [
+        {
+            "id": str(sess.id),
+            "branchName": sess.branch_name,
+            "prNumber": sess.pr_number,
+            "prUrl": sess.pr_url,
+            "commitCount": sess.commit_count,
+            "businessDate": sess.business_date,
+            "status": sess.status,
+            "changedFiles": sess.changed_files or [],
+            "createdAt": sess.created_at.isoformat() if sess.created_at else None,
+            "updatedAt": sess.updated_at.isoformat() if sess.updated_at else None,
+            "username": username,
+            "displayName": display_name,
+        }
+        for sess, username, display_name in rows
+    ]

package/notes-api/app/startup.py

@@ -0,0 +1,66 @@
+"""Startup: ensure tables and seed data."""
+
+from sqlalchemy import select
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database import async_session_factory
+from app.models import NotesSetting, NotesUser
+from app.security import hash_password
+
+DEFAULT_SETTINGS = [
+    {"key": "business_day_start_hour", "value": 6},
+    {"key": "timezone", "value": "Asia/Tokyo"},
+    {"key": "pr_idle_timeout_sec", "value": 300},
+    {"key": "max_login_attempts", "value": 5},
+    {"key": "lockout_duration_min", "value": 15},
+]
+
+
+async def ensure_tables_and_seed() -> None:
+    """Create tables and seed admin user + default settings."""
+    from app.database import engine
+    from app.models import (  # noqa: F401
+        NotesAuditLog,
+        NotesEditingSession,
+        NotesSetting,
+        NotesUser,
+    )
+    from app.models.base import Base
+
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    async with async_session_factory() as session:
+        await _seed_admin(session)
+        await _seed_settings(session)
+
+
+async def _seed_admin(session: AsyncSession) -> None:
+    """Create admin user if not exists."""
+    result = await session.execute(
+        select(NotesUser).where(NotesUser.username == settings.notes_admin_username)
+    )
+    if result.scalar_one_or_none() is None:
+        admin = NotesUser(
+            username=settings.notes_admin_username,
+            display_name="Administrator",
+            password_hash=hash_password(settings.notes_admin_password),
+            role="admin",
+        )
+        session.add(admin)
+        await session.commit()
+        print(f'[seed] Admin user "{settings.notes_admin_username}" created')
+
+
+async def _seed_settings(session: AsyncSession) -> None:
+    """Insert default settings (on conflict do nothing)."""
+    for item in DEFAULT_SETTINGS:
+        stmt = insert(NotesSetting).values(
+            key=item["key"],
+            value=item["value"],
+        ).on_conflict_do_nothing(index_elements=["key"])
+        await session.execute(stmt)
+    await session.commit()
+    print("[seed] Default settings ensured")

package/notes-api/docker/Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends libpq-dev gcc && rm -rf /var/lib/apt/lists/*
+
+RUN pip install uv
+
+COPY . .
+
+RUN uv pip install --system .
+
+EXPOSE 3100
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-3100}"]

package/notes-api/docker/Dockerfile.test

@@ -0,0 +1,14 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends libpq-dev gcc && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --no-cache-dir uv
+
+COPY pyproject.toml uv.lock* ./
+RUN uv pip install --system ".[dev]"
+
+COPY . .
+
+CMD ["sh", "-c", "ruff check . && pytest -q"]

package/notes-api/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "notes-api"
+version = "0.1.0"
+description = "ripla Notes API - FastAPI backend for docs viewing/editing"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.34.0",
+    "sqlalchemy[asyncio]>=2.0.36",
+    "asyncpg>=0.30.0",
+    "alembic>=1.14.0",
+    "pydantic>=2.10.0",
+    "pydantic-settings>=2.7.0",
+    "python-multipart>=0.0.18",
+    "psycopg2-binary>=2.9.0",
+    "pyjwt>=2.9.0",
+    "bcrypt>=4.2.0",
+    "httpx>=0.28.0",
+    "tzdata>=2024.1; sys_platform == 'win32'",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.25.0",
+    "httpx>=0.28.0",
+    "ruff>=0.9.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "A", "SIM", "TCH"]
+ignore = [
+    "B008",
+    "A002",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"scripts/*.py" = ["E501"]
+"alembic/**/*.py" = ["E501"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

package/notes-api/tests/conftest.py

@@ -0,0 +1,21 @@
+"""Pytest fixtures for notes-api."""
+
+import os
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+# Skip DB-dependent startup during tests
+os.environ["TESTING"] = "true"
+
+from app.main import app  # noqa: E402
+
+
+@pytest.fixture
+async def client():
+    """Async test client."""
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+    ) as ac:
+        yield ac

package/notes-api/tests/test_business_date.py

@@ -0,0 +1,32 @@
+"""Test business date calculation."""
+
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+import pytest
+
+from app.services.business_date import compute_business_date
+
+
+def test_compute_business_date_before_start():
+    """Before start_hour counts as previous day."""
+    tz = ZoneInfo("Asia/Tokyo")
+    now = datetime(2026, 2, 27, 5, 0, 0, tzinfo=tz)
+    result = compute_business_date(now, 6, "Asia/Tokyo")
+    assert result == "2026-02-26"
+
+
+def test_compute_business_date_after_start():
+    """After start_hour counts as same day."""
+    tz = ZoneInfo("Asia/Tokyo")
+    now = datetime(2026, 2, 27, 10, 0, 0, tzinfo=tz)
+    result = compute_business_date(now, 6, "Asia/Tokyo")
+    assert result == "2026-02-27"
+
+
+def test_compute_business_date_at_boundary():
+    """At exactly start_hour counts as same day."""
+    tz = ZoneInfo("Asia/Tokyo")
+    now = datetime(2026, 2, 27, 6, 0, 0, tzinfo=tz)
+    result = compute_business_date(now, 6, "Asia/Tokyo")
+    assert result == "2026-02-27"

package/notes-api/tests/test_health.py

@@ -0,0 +1,11 @@
+"""Test health endpoint."""
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_health(client):
+    """Health check returns ok."""
+    resp = await client.get("/api/health")
+    assert resp.status_code == 200
+    assert resp.json() == {"status": "ok"}