cc-discussion 1.0.0__py3-none-any.whl

backend/__init__.py

@@ -0,0 +1 @@
+"""Claude Discussion Room Backend"""

backend/__main__.py

@@ -0,0 +1,7 @@
+"""
+python -m backend で実行可能にする
+"""
+from backend.cli import main
+
+if __name__ == '__main__':
+    main()

backend/cli.py

@@ -0,0 +1,44 @@
+"""
+cc-discussion CLI
+=================
+
+uvx cc-discussion または python -m backend で実行
+
+Usage:
+    cc-discussion                    # デフォルト設定で起動
+    cc-discussion --port 9000        # ポート指定
+    cc-discussion --no-browser       # ブラウザを開かない
+    cc-discussion --reload           # 開発モード（ホットリロード）
+"""
+import webbrowser
+from threading import Timer
+
+import click
+import uvicorn
+
+
+@click.command()
+@click.option('--host', default='127.0.0.1', help='バインドするホスト')
+@click.option('--port', default=8888, type=int, help='バインドするポート')
+@click.option('--no-browser', is_flag=True, help='ブラウザを自動で開かない')
+@click.option('--reload', is_flag=True, help='ホットリロードを有効化（開発用）')
+@click.version_option(version='1.0.0', prog_name='cc-discussion')
+def main(host: str, port: int, no_browser: bool, reload: bool):
+    """Claude Discussion Room - マルチエージェント議論プラットフォーム"""
+    url = f"http://{host}:{port}"
+    click.echo(f"Starting cc-discussion on {url}")
+
+    # ブラウザを少し遅らせて開く（サーバー起動を待つ）
+    if not no_browser:
+        Timer(1.5, lambda: webbrowser.open(url)).start()
+
+    uvicorn.run(
+        "backend.main:app",
+        host=host,
+        port=port,
+        reload=reload,
+    )
+
+
+if __name__ == '__main__':
+    main()

backend/main.py

@@ -0,0 +1,167 @@
+"""
+FastAPI Main Application
+========================
+
+Main entry point for the Claude Discussion Room server.
+"""
+
+# Load environment variables from .env file first
+from dotenv import load_dotenv
+load_dotenv()
+
+import asyncio
+import logging
+import sys
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+# Fix for Windows subprocess support
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+
+from fastapi import FastAPI, WebSocket
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from .routers import history_router, rooms_router
+from .websocket import room_websocket
+from .services.discussion_orchestrator import cleanup_all_orchestrators
+from .models.database import get_engine
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# Paths - Support both development and packaged installation
+ROOT_DIR = Path(__file__).parent.parent
+UI_DIST_DIR = ROOT_DIR / "frontend" / "dist"
+
+# Alternative locations for packaged installation
+if not UI_DIST_DIR.exists():
+    # Try relative to the backend package
+    UI_DIST_DIR = Path(__file__).parent / ".." / "frontend" / "dist"
+    if not UI_DIST_DIR.exists():
+        UI_DIST_DIR = None  # No frontend dist available
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup and shutdown."""
+    # Startup - initialize database
+    get_engine()
+    logger.info("Database initialized")
+
+    yield
+
+    # Shutdown - cleanup all orchestrators
+    await cleanup_all_orchestrators()
+    logger.info("Cleanup complete")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="Claude Discussion Room",
+    description="Multi-Claude discussion platform with ClaudeCode context",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "http://127.0.0.1:5173",
+        "http://localhost:8888",
+        "http://127.0.0.1:8888",
+        "http://localhost:9000",
+        "http://127.0.0.1:9000",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(history_router)
+app.include_router(rooms_router)
+
+
+# WebSocket endpoint
+@app.websocket("/ws/rooms/{room_id}")
+async def websocket_endpoint(websocket: WebSocket, room_id: int):
+    """WebSocket endpoint for discussion room updates."""
+    await room_websocket(websocket, room_id)
+
+
+# Health check
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+# SDK availability check
+@app.get("/api/config/available-agents")
+async def get_available_agents():
+    """Check which agent SDKs are installed and available."""
+    available = []
+
+    # Check ClaudeCode SDK
+    try:
+        from claude_agent_sdk import ClaudeSDKClient
+        available.append("claude")
+    except ImportError:
+        pass
+
+    # Check Codex SDK
+    try:
+        from codex_sdk import Codex
+        available.append("codex")
+    except ImportError:
+        pass
+
+    return {"available_agents": available}
+
+
+# Static file serving (Production)
+if UI_DIST_DIR and UI_DIST_DIR.exists():
+    app.mount("/assets", StaticFiles(directory=UI_DIST_DIR / "assets"), name="assets")
+
+    @app.get("/")
+    async def serve_index():
+        """Serve the React app index.html."""
+        return FileResponse(UI_DIST_DIR / "index.html")
+
+    @app.get("/{path:path}")
+    async def serve_spa(path: str):
+        """Serve static files or fall back to index.html for SPA routing."""
+        if path.startswith("api/") or path.startswith("ws/"):
+            return {"error": "Not found"}
+
+        file_path = (UI_DIST_DIR / path).resolve()
+
+        # Prevent path traversal
+        try:
+            file_path.relative_to(UI_DIST_DIR.resolve())
+        except ValueError:
+            return FileResponse(UI_DIST_DIR / "index.html")
+
+        if file_path.exists() and file_path.is_file():
+            return FileResponse(file_path)
+
+        return FileResponse(UI_DIST_DIR / "index.html")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "backend.main:app",
+        host="127.0.0.1",
+        port=8888,
+        reload=True,
+    )

backend/models/__init__.py

@@ -0,0 +1,2 @@
+"""Database models for Claude Discussion Room."""
+from .database import Base, DiscussionRoom, RoomParticipant, DiscussionMessage, RoomStatus

backend/models/database.py

@@ -0,0 +1,244 @@
+"""
+Database Models
+===============
+
+SQLite database schema for discussion rooms using SQLAlchemy.
+"""
+
+import enum
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Generator
+
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    Enum,
+    ForeignKey,
+    Integer,
+    String,
+    Text,
+    create_engine,
+)
+from sqlalchemy.orm import DeclarativeBase, Session, relationship, sessionmaker
+from sqlalchemy.types import JSON
+
+
+def _utc_now() -> datetime:
+    """Return current UTC time."""
+    return datetime.now(timezone.utc)
+
+
+class Base(DeclarativeBase):
+    """SQLAlchemy 2.0 style declarative base."""
+    pass
+
+
+class RoomStatus(enum.Enum):
+    """Status of a discussion room."""
+    WAITING = "waiting"      # Room created, waiting for discussion to start
+    ACTIVE = "active"        # Discussion in progress
+    PAUSED = "paused"        # Discussion paused
+    COMPLETED = "completed"  # Discussion ended
+
+
+class MeetingType(enum.Enum):
+    """会議タイプ"""
+    PROGRESS_CHECK = "progress_check"      # 1. 進捗・状況確認
+    SPEC_ALIGNMENT = "spec_alignment"      # 2. 要件・仕様の認識合わせ
+    TECHNICAL_REVIEW = "technical_review"  # 3. 技術検討・設計判断
+    ISSUE_RESOLUTION = "issue_resolution"  # 4. 課題・不具合対応
+    REVIEW = "review"                      # 5. レビュー
+    PLANNING = "planning"                  # 6. 計画・タスク整理
+    RELEASE_OPS = "release_ops"            # 7. リリース・運用判断
+    RETROSPECTIVE = "retrospective"        # 8. 改善・振り返り
+    OTHER = "other"                        # 9. その他（カスタム）
+
+
+class AgentType(enum.Enum):
+    """エージェントタイプ"""
+    CLAUDE = "claude"
+    CODEX = "codex"
+
+
+class DiscussionRoom(Base):
+    """A discussion room where multiple Claudes converse."""
+    __tablename__ = "discussion_rooms"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(200), nullable=False)
+    topic = Column(Text, nullable=True)
+    status = Column(
+        Enum(RoomStatus, native_enum=False, values_callable=lambda x: [e.value for e in x]),
+        default=RoomStatus.WAITING
+    )
+    max_turns = Column(Integer, default=20)
+    current_turn = Column(Integer, default=0)
+    created_at = Column(DateTime, default=_utc_now)
+    updated_at = Column(DateTime, default=_utc_now, onupdate=_utc_now)
+
+    # Meeting type settings
+    meeting_type = Column(
+        Enum(MeetingType, native_enum=False, values_callable=lambda x: [e.value for e in x]),
+        default=MeetingType.TECHNICAL_REVIEW
+    )
+    custom_meeting_description = Column(Text, nullable=True)  # "その他"選択時のカスタム説明
+    language = Column(String(10), default="ja")
+
+    participants = relationship(
+        "RoomParticipant",
+        back_populates="room",
+        cascade="all, delete-orphan"
+    )
+    messages = relationship(
+        "DiscussionMessage",
+        back_populates="room",
+        cascade="all, delete-orphan"
+    )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "topic": self.topic,
+            "status": self.status.value if self.status else "waiting",
+            "max_turns": self.max_turns,
+            "current_turn": self.current_turn,
+            "meeting_type": self.meeting_type.value if self.meeting_type else "technical_review",
+            "custom_meeting_description": self.custom_meeting_description,
+            "language": self.language or "ja",
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+            "participant_count": len(self.participants) if self.participants else 0,
+        }
+
+
+class RoomParticipant(Base):
+    """A Claude participant in a discussion room."""
+    __tablename__ = "room_participants"
+
+    id = Column(Integer, primary_key=True, index=True)
+    room_id = Column(Integer, ForeignKey("discussion_rooms.id"), nullable=False, index=True)
+
+    # Participant identity
+    name = Column(String(50), nullable=False)
+    role = Column(String(100), nullable=True)
+    color = Column(String(7), default="#6366f1")
+
+    # Context injection from ClaudeCode history
+    context_project_dir = Column(String(500), nullable=True)
+    context_session_id = Column(String(100), nullable=True)
+    context_summary = Column(Text, nullable=True)
+
+    # State
+    is_speaking = Column(Boolean, default=False)
+    message_count = Column(Integer, default=0)
+
+    # Agent settings
+    is_facilitator = Column(Boolean, default=False)
+    agent_type = Column(
+        Enum(AgentType, native_enum=False, values_callable=lambda x: [e.value for e in x]),
+        default=AgentType.CLAUDE
+    )
+
+    room = relationship("DiscussionRoom", back_populates="participants")
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "room_id": self.room_id,
+            "name": self.name,
+            "role": self.role,
+            "color": self.color,
+            "context_project_dir": self.context_project_dir,
+            "context_session_id": self.context_session_id,
+            "has_context": bool(self.context_session_id),
+            "is_speaking": self.is_speaking,
+            "message_count": self.message_count,
+            "is_facilitator": self.is_facilitator or False,
+            "agent_type": self.agent_type.value if self.agent_type else "claude",
+        }
+
+
+class DiscussionMessage(Base):
+    """A message in the discussion."""
+    __tablename__ = "discussion_messages"
+
+    id = Column(Integer, primary_key=True, index=True)
+    room_id = Column(Integer, ForeignKey("discussion_rooms.id"), nullable=False, index=True)
+    participant_id = Column(Integer, ForeignKey("room_participants.id"), nullable=True)
+
+    role = Column(String(20), nullable=False)  # "system" | "participant" | "moderator"
+    content = Column(Text, nullable=False)
+    extra_data = Column(JSON, nullable=True)  # Tool calls, thinking, etc.
+
+    turn_number = Column(Integer, nullable=False)
+    created_at = Column(DateTime, default=_utc_now)
+
+    room = relationship("DiscussionRoom", back_populates="messages")
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "room_id": self.room_id,
+            "participant_id": self.participant_id,
+            "role": self.role,
+            "content": self.content,
+            "extra_data": self.extra_data,
+            "turn_number": self.turn_number,
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+        }
+
+
+# Database setup
+DATABASE_PATH = Path(__file__).parent.parent.parent / "discussion.db"
+
+
+def get_database_url() -> str:
+    """Return the SQLAlchemy database URL."""
+    return f"sqlite:///{DATABASE_PATH.as_posix()}"
+
+
+_engine = None
+_session_maker = None
+
+
+def get_engine():
+    """Get or create the database engine."""
+    global _engine
+    if _engine is None:
+        _engine = create_engine(
+            get_database_url(),
+            connect_args={"check_same_thread": False}
+        )
+        Base.metadata.create_all(bind=_engine)
+    return _engine
+
+
+def get_session_maker():
+    """Get or create the session maker."""
+    global _session_maker
+    if _session_maker is None:
+        _session_maker = sessionmaker(
+            autocommit=False,
+            autoflush=False,
+            bind=get_engine()
+        )
+    return _session_maker
+
+
+def get_db() -> Generator[Session, None, None]:
+    """Dependency for FastAPI to get database session."""
+    SessionLocal = get_session_maker()
+    db = SessionLocal()
+    try:
+        yield db
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()

backend/routers/__init__.py

@@ -0,0 +1,3 @@
+"""API Routers for Claude Discussion Room."""
+from .history import router as history_router
+from .rooms import router as rooms_router

backend/routers/history.py

@@ -0,0 +1,202 @@
+"""
+History Router
+==============
+
+API endpoints for browsing ClaudeCode conversation history.
+"""
+
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services.history_reader import (
+    list_projects,
+    list_sessions,
+    load_session_history,
+    decode_session_id,
+)
+from ..services.codex_history_reader import (
+    list_codex_projects,
+    list_codex_sessions,
+)
+
+router = APIRouter(prefix="/api/history", tags=["history"])
+
+
+class ProjectResponse(BaseModel):
+    """Response model for a project."""
+    id: str
+    name: str
+    path: str
+    last_modified_at: str
+
+
+class SessionResponse(BaseModel):
+    """Response model for a session."""
+    id: str
+    jsonl_file_path: str
+    last_modified_at: str
+    message_count: int
+    first_user_message: Optional[str]
+
+
+class ToolCall(BaseModel):
+    """Tool call model."""
+    id: Optional[str]
+    name: Optional[str]
+    input: dict
+
+
+class ToolResult(BaseModel):
+    """Tool result model."""
+    tool_use_id: Optional[str]
+    content: Any
+    is_error: bool = False
+
+
+class ConversationResponse(BaseModel):
+    """Response model for a conversation message."""
+    type: str
+    uuid: str
+    timestamp: str
+    content: Any
+    is_sidechain: bool
+    parent_uuid: Optional[str]
+    tool_calls: List[ToolCall]
+    tool_results: List[ToolResult]
+
+
+class SessionDetailResponse(BaseModel):
+    """Response model for session detail."""
+    id: str
+    jsonl_file_path: str
+    conversations: List[ConversationResponse]
+
+
+@router.get("/projects", response_model=List[ProjectResponse])
+async def get_claude_projects():
+    """List all ClaudeCode projects with history."""
+    projects = list_projects()
+    return [
+        ProjectResponse(
+            id=p.id,
+            name=p.name,
+            path=p.path,
+            last_modified_at=p.last_modified_at.isoformat(),
+        )
+        for p in projects
+    ]
+
+
+@router.get("/projects/{project_id}/sessions", response_model=List[SessionResponse])
+async def get_project_sessions(project_id: str, limit: int = 50):
+    """Get all sessions for a project."""
+    sessions = list_sessions(project_id, limit=limit)
+    return [
+        SessionResponse(
+            id=s.id,
+            jsonl_file_path=s.jsonl_file_path,
+            last_modified_at=s.last_modified_at.isoformat(),
+            message_count=s.message_count,
+            first_user_message=s.first_user_message,
+        )
+        for s in sessions
+    ]
+
+
+@router.get("/sessions/{session_id}", response_model=SessionDetailResponse)
+async def get_session_detail(session_id: str):
+    """Get full session detail with all conversations."""
+    try:
+        messages = load_session_history(session_id)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return SessionDetailResponse(
+        id=session_id,
+        jsonl_file_path=decode_session_id(session_id),
+        conversations=[
+            ConversationResponse(
+                type=m.type,
+                uuid=m.uuid,
+                timestamp=m.timestamp,
+                content=m.content,
+                is_sidechain=m.is_sidechain,
+                parent_uuid=m.parent_uuid,
+                tool_calls=[
+                    ToolCall(
+                        id=tc.get('id'),
+                        name=tc.get('name'),
+                        input=tc.get('input', {}),
+                    )
+                    for tc in m.tool_calls
+                ],
+                tool_results=[
+                    ToolResult(
+                        tool_use_id=tr.get('tool_use_id'),
+                        content=tr.get('content'),
+                        is_error=tr.get('is_error', False),
+                    )
+                    for tr in m.tool_results
+                ],
+            )
+            for m in messages
+        ],
+    )
+
+
+# ============================================
+# Codex History Endpoints
+# ============================================
+
+class CodexProjectResponse(BaseModel):
+    """Response model for a Codex project."""
+    id: str
+    name: str
+    path: str
+    last_modified_at: str
+    session_count: int
+
+
+class CodexSessionResponse(BaseModel):
+    """Response model for a Codex session."""
+    id: str
+    session_uuid: str
+    jsonl_file_path: str
+    first_user_message: Optional[str]
+    message_count: int
+    last_modified_at: str
+
+
+@router.get("/codex/projects", response_model=List[CodexProjectResponse])
+async def get_codex_projects():
+    """List all Codex projects with history."""
+    projects = list_codex_projects()
+    return [
+        CodexProjectResponse(
+            id=p["id"],
+            name=p["name"],
+            path=p["path"],
+            last_modified_at=p["last_modified_at"],
+            session_count=p["session_count"],
+        )
+        for p in projects
+    ]
+
+
+@router.get("/codex/projects/{project_id}/sessions", response_model=List[CodexSessionResponse])
+async def get_codex_project_sessions(project_id: str):
+    """Get all sessions for a Codex project."""
+    sessions = list_codex_sessions(project_id)
+    return [
+        CodexSessionResponse(
+            id=s["id"],
+            session_uuid=s["session_uuid"],
+            jsonl_file_path=s["jsonl_file_path"],
+            first_user_message=s["first_user_message"],
+            message_count=s["message_count"],
+            last_modified_at=s["last_modified_at"],
+        )
+        for s in sessions
+    ]