fix cargo

clean
Add complete ai.card Rust implementation
2025-06-09 03:58:38 +09:00 · 2025-06-09 02:53:50 +09:00 · 2025-06-09 01:51:15 +09:00 · 2025-06-09 01:51:15 +09:00 · 2025-06-02 18:24:43 +09:00 · 2025-06-02 00:39:26 +09:00
148 changed files with 12749 additions and 341 deletions
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -0,0 +1,34 @@
 {
  "permissions": {
    "allow": [
      "WebFetch(domain:card.syui.ai)",
      "Bash(mkdir:*)",
      "Bash(chmod:*)",
      "Bash(./start_server.sh:*)",
      "Bash(npm run dev:*)",
      "Bash(npm install)",
      "WebFetch(domain:github.com)",
      "Bash(npm run build:*)",
      "Bash(npm run preview:*)",
      "Bash(curl:*)",
      "Bash(sudo kill:*)",
      "Bash(launchctl:*)",
      "Bash(ls:*)",
      "Bash(cat:*)",
      "Bash(find:*)",
      "Bash(cloudflared:*)",
      "Bash(grep:*)",
      "Bash(nslookup:*)",
      "Bash(sqlite3:*)",
      "Bash(kill:*)",
      "Bash(pkill:*)",
      "WebFetch(domain:docs.bsky.app)",
      "Bash(npm install:*)",
      "WebFetch(domain:raw.githubusercontent.com)",
      "WebFetch(domain:www.npmjs.com)",
      "Bash(rm:*)",
      "Bash(cargo:*)"
    ],
    "deny": []
  }
 }
--- a/.env.development
+++ b/.env.development
@@ -0,0 +1,18 @@
 # Development configuration for ai.card
 # This file is used for local development
 # Web Frontend Configuration
 VITE_WEB_HOST=http://localhost:5173
 VITE_API_HOST=http://localhost:8000
 VITE_WEB_PORT=5173
 # API Backend Configuration
 API_HOST=localhost
 API_PORT=8000
 # OAuth Configuration
 VITE_OAUTH_CLIENT_NAME=ai.card
 VITE_OAUTH_REDIRECT_PATH=/oauth/callback
 # Feature Flags
 VITE_ENABLE_AI_FEATURES=true
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -1,31 +0,0 @@
 name: github pages
 on:
  push:
    branches:
    - main
 jobs:
  build-deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
    - uses: actions/setup-node@v1
      with:
        node-version: 14
        ref: main
        submodules: true
        fetch-depth: 0
    - run: yarn install
    - name: Build
      env: 
        TZ: "Asia/Tokyo"
      run: |
           yarn build
    - name: Deploy
      uses: peaceiris/actions-gh-pages@v3
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
        publish_dir: ./dist
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,66 @@
 # Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.so
 .Python
 env/
 venv/
 .venv/
 .env
 # FastAPI
 .pytest_cache/
 .coverage
 htmlcov/
 *.log
 # Database
 *.db
 *.sqlite3
 # IDE
 .vscode/
 .idea/
 *.swp
 *.swo
 # macOS
 .DS_Store
 # Node
 node_modules/
 dist/
 build/
 .next/
 .nuxt/
 *.log*
 # iOS
 *.xcworkspace
 xcuserdata/
 *.xcscmblueprint
 *.xccheckout
 DerivedData/
 *.ipa
 *.dSYM.zip
 *.dSYM
 Pods/
 # Secrets
 .env.local
 .env.production
 secrets/
 *.key
 *.pem
 # Origin
 node_modules
 dist
-*.lock
+tt
 app.js
 yarn-error.log
 package-lock.json
 yarn.lock
 **DS_Store
 cloudflared-config*
--- a/1
+++ b/1
@@ -1 +0,0 @@
 card.syui.ai
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -0,0 +1,54 @@
 [package]
 name = "aicard"
 version = "0.1.0"
 edition = "2021"
 description = "ai.card API server - Rust implementation of autonomous card collection system"
 authors = ["syui"]
 [dependencies]
 # Core Web Framework
 axum = { version = "0.7", features = ["macros", "multipart"] }
 tokio = { version = "1.0", features = ["full"] }
 tower = { version = "0.4", features = ["full"] }
 tower-http = { version = "0.5", features = ["cors", "trace"] }
 # Database & ORM
 sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "sqlite", "uuid", "chrono", "migrate"] }
 uuid = { version = "1.0", features = ["v4", "serde"] }
 # Serialization & Validation
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 validator = { version = "0.18", features = ["derive"] }
 # Date/Time
 chrono = { version = "0.4", features = ["serde"] }
 # Authentication & Security
 jsonwebtoken = "9.0"
 bcrypt = "0.15"
 # HTTP Client (for atproto integration)
 reqwest = { version = "0.11", features = ["json"] }
 # Configuration
 config = "0.13"
 dotenvy = "0.15"
 # CLI
 clap = { version = "4.0", features = ["derive"] }
 # Random (for gacha system)
 rand = "0.8"
 # Error Handling
 anyhow = "1.0"
 thiserror = "1.0"
 # Logging
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 # Development
 serde_yaml = "0.9"
 dirs = "5.0"
--- a/README.md
+++ b/README.md
@@ -0,0 +1,143 @@
 # ai.card プロジェクト固有情報
 ## プロジェクト概要
 - **名前**: ai.card
 - **パッケージ**: aicard
 - **タイプ**: atproto基盤カードゲーム
 - **役割**: ユーザーデータ主権カードゲームシステム
 ## 実装状況
 ### 現在の状況
 - **ai.bot統合**: ai.botの機能として実装済み
 - **カード取得**: atproto accountでmentionすると1日1回カード取得可能
 - **データ管理**: ai.api (MCP server) でユーザー管理
 ### 独立MCPサーバー（ai.gpt連携）
 - **場所**: `/Users/syui/ai/gpt/card/`
 - **サーバー**: FastAPI + fastapi_mcp (port 8000)
 - **統合**: ai.gptサーバーからHTTP連携
 ## アーキテクチャ構成
 ### 技術スタック
 - **Backend**: FastAPI + MCP
 - **Frontend**: React Web UI + SwiftUI iOS app
 - **Data**: atproto collection record（ユーザー所有）
 - **Auth**: OAuth 2.1 scope（実装待ち）
 ### データフロー
 ```
 ユーザー → ai.bot mention → カード生成 → atproto collection → ユーザー所有
    ↑                                ↓
    ← iOS app表示 ← ai.card API ←
 ```
 ## 移行計画
 ### Phase 1: 独立化
 - **iOS移植**: Claude担当予定
 - **Web UI**: React実装
 - **API独立**: ai.botからの分離
 ### Phase 2: データ主権実装
 - **atproto collection**: カードデータをユーザー所有に
 - **OAuth 2.1**: 不正防止機能実装
 - **画像ファイル**: Cloudflare Pages最適化
 ### Phase 3: ゲーム機能拡張
 - **ガチャシステム**: 確率・レアリティ管理
 - **トレード機能**: ユーザー間カード交換
 - **デッキ構築**: カードゲーム戦略要素
 ## yui system適用
 ### 唯一性担保
 - **カード効果**: アカウント固有の効果設定
 - **改ざん防止**: ハッシュ・署名による保証
 - **ゲームバランス**: 唯一性による公平性維持
 ### ai.verse連携
 - **ゲーム内アイテム**: ai.verseでのカード利用
 - **固有スキル**: カードとキャラクターの連動
 - **現実反映**: カード取得がゲーム内能力に影響
 ## ディレクトリ構成
 ```
 /Users/syui/ai/gpt/card/
 ├── api/              # FastAPI + MCP server
 ├── web/              # React Web UI
 ├── ios/              # SwiftUI iOS app
 └── docs/            # 開発ドキュメント
 ```
 ## MCPツール（ai.gpt連携）
 ### カード管理
 - **card_get_user_cards**: ユーザーカード取得
 - **card_draw_card**: ガチャ実行
 - **card_analyze_collection**: コレクション分析
 - **card_check_daily_limit**: 日次制限確認
 - **card_get_card_stats**: カード統計情報
 - **card_manage_deck**: デッキ管理
 ## 開発状況
 ### 完成済み機能
 - ✅ **基本カード生成**: ai.bot統合での1日1回取得
 - ✅ **atproto連携**: mention機能
 - ✅ **MCP統合**: ai.gptからの操作
 ### 開発中機能
 - 🔧 **iOS app**: SwiftUI実装
 - 🔧 **Web UI**: React実装  
 - 🔧 **独立API**: FastAPI server
 ### 将来機能
 - 📋 **OAuth 2.1**: 不正防止強化
 - 📋 **画像最適化**: Cloudflare Pages
 - 📋 **ゲーム拡張**: トレード・デッキ戦略
 ## ai.botからの移行詳細
 ### 現在のai.bot実装
 - **Rust製**: seahorse CLI framework
 - **atproto連携**: mention機能でカード配布
 - **日次制限**: 1アカウント1日1回取得
 - **自動生成**: AI絵画（Leonardo.AI + Stable Diffusion）
 ### 独立化の理由
 - **iOS展開**: モバイルアプリでの独立した体験
 - **ゲーム拡張**: デッキ構築・バトル機能の追加
 - **データ主権**: ユーザーによる完全なデータ所有
 - **スケーラビリティ**: サーバー負荷分散
 ## 技術的課題と解決策
 ### データ改ざん防止
 - **短期**: MCP serverによる検証
 - **中期**: OAuth 2.1 scope実装待ち
 - **長期**: ブロックチェーン的整合性チェック
 ### スケーラビリティ
 - **画像配信**: Cloudflare Pages活用
 - **API負荷**: FastAPIによる高速処理
 - **データ保存**: atproto分散ストレージ
 ### ユーザー体験
 - **直感的UI**: iOS/Webでの統一UX
 - **リアルタイム更新**: WebSocketでの即座反映
 - **オフライン対応**: ローカルキャッシュ機能
 ## ai.game連携構想
 ### Play-to-Work統合
 - **カードゲームプレイ → 業務成果変換**: ai.gameデバイスでの労働ゲーム化
 - **デッキ構築戦略 → 企業戦略思考**: カード組み合わせが戦略思考を鍛練
 - **トレード交渉 → ビジネススキル**: 他プレイヤーとの交渉が実務能力向上
 ### メタバース展開
 - **ai.verse統合**: 3D世界でのカードバトル
 - **アバター連動**: 所有カードがキャラクター能力に影響
 - **配信コンテンツ**: カードゲームが配信可能なエンターテイメント
--- a/claude.md
+++ b/claude.md
@@ -0,0 +1,143 @@
 # ai.card プロジェクト固有情報
 ## プロジェクト概要
 - **名前**: ai.card
 - **パッケージ**: aicard
 - **タイプ**: atproto基盤カードゲーム
 - **役割**: ユーザーデータ主権カードゲームシステム
 ## 実装状況
 ### 現在の状況
 - **ai.bot統合**: ai.botの機能として実装済み
 - **カード取得**: atproto accountでmentionすると1日1回カード取得可能
 - **データ管理**: ai.api (MCP server) でユーザー管理
 ### 独立MCPサーバー（ai.gpt連携）
 - **場所**: `/Users/syui/ai/gpt/card/`
 - **サーバー**: FastAPI + fastapi_mcp (port 8000)
 - **統合**: ai.gptサーバーからHTTP連携
 ## アーキテクチャ構成
 ### 技術スタック
 - **Backend**: FastAPI + MCP
 - **Frontend**: React Web UI + SwiftUI iOS app
 - **Data**: atproto collection record（ユーザー所有）
 - **Auth**: OAuth 2.1 scope（実装待ち）
 ### データフロー
 ```
 ユーザー → ai.bot mention → カード生成 → atproto collection → ユーザー所有
    ↑                                ↓
    ← iOS app表示 ← ai.card API ←
 ```
 ## 移行計画
 ### Phase 1: 独立化
 - **iOS移植**: Claude担当予定
 - **Web UI**: React実装
 - **API独立**: ai.botからの分離
 ### Phase 2: データ主権実装
 - **atproto collection**: カードデータをユーザー所有に
 - **OAuth 2.1**: 不正防止機能実装
 - **画像ファイル**: Cloudflare Pages最適化
 ### Phase 3: ゲーム機能拡張
 - **ガチャシステム**: 確率・レアリティ管理
 - **トレード機能**: ユーザー間カード交換
 - **デッキ構築**: カードゲーム戦略要素
 ## yui system適用
 ### 唯一性担保
 - **カード効果**: アカウント固有の効果設定
 - **改ざん防止**: ハッシュ・署名による保証
 - **ゲームバランス**: 唯一性による公平性維持
 ### ai.verse連携
 - **ゲーム内アイテム**: ai.verseでのカード利用
 - **固有スキル**: カードとキャラクターの連動
 - **現実反映**: カード取得がゲーム内能力に影響
 ## ディレクトリ構成
 ```
 /Users/syui/ai/gpt/card/
 ├── api/              # FastAPI + MCP server
 ├── web/              # React Web UI
 ├── ios/              # SwiftUI iOS app
 └── docs/            # 開発ドキュメント
 ```
 ## MCPツール（ai.gpt連携）
 ### カード管理
 - **card_get_user_cards**: ユーザーカード取得
 - **card_draw_card**: ガチャ実行
 - **card_analyze_collection**: コレクション分析
 - **card_check_daily_limit**: 日次制限確認
 - **card_get_card_stats**: カード統計情報
 - **card_manage_deck**: デッキ管理
 ## 開発状況
 ### 完成済み機能
 - ✅ **基本カード生成**: ai.bot統合での1日1回取得
 - ✅ **atproto連携**: mention機能
 - ✅ **MCP統合**: ai.gptからの操作
 ### 開発中機能
 - 🔧 **iOS app**: SwiftUI実装
 - 🔧 **Web UI**: React実装  
 - 🔧 **独立API**: FastAPI server
 ### 将来機能
 - 📋 **OAuth 2.1**: 不正防止強化
 - 📋 **画像最適化**: Cloudflare Pages
 - 📋 **ゲーム拡張**: トレード・デッキ戦略
 ## ai.botからの移行詳細
 ### 現在のai.bot実装
 - **Rust製**: seahorse CLI framework
 - **atproto連携**: mention機能でカード配布
 - **日次制限**: 1アカウント1日1回取得
 - **自動生成**: AI絵画（Leonardo.AI + Stable Diffusion）
 ### 独立化の理由
 - **iOS展開**: モバイルアプリでの独立した体験
 - **ゲーム拡張**: デッキ構築・バトル機能の追加
 - **データ主権**: ユーザーによる完全なデータ所有
 - **スケーラビリティ**: サーバー負荷分散
 ## 技術的課題と解決策
 ### データ改ざん防止
 - **短期**: MCP serverによる検証
 - **中期**: OAuth 2.1 scope実装待ち
 - **長期**: ブロックチェーン的整合性チェック
 ### スケーラビリティ
 - **画像配信**: Cloudflare Pages活用
 - **API負荷**: FastAPIによる高速処理
 - **データ保存**: atproto分散ストレージ
 ### ユーザー体験
 - **直感的UI**: iOS/Webでの統一UX
 - **リアルタイム更新**: WebSocketでの即座反映
 - **オフライン対応**: ローカルキャッシュ機能
 ## ai.game連携構想
 ### Play-to-Work統合
 - **カードゲームプレイ → 業務成果変換**: ai.gameデバイスでの労働ゲーム化
 - **デッキ構築戦略 → 企業戦略思考**: カード組み合わせが戦略思考を鍛練
 - **トレード交渉 → ビジネススキル**: 他プレイヤーとの交渉が実務能力向上
 ### メタバース展開
 - **ai.verse統合**: 3D世界でのカードバトル
 - **アバター連動**: 所有カードがキャラクター能力に影響
 - **配信コンテンツ**: カードゲームが配信可能なエンターテイメント
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -0,0 +1,64 @@
 version: '3.8'
 services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: aicard
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
  api:
    build: 
      context: ./api
      dockerfile: Dockerfile
    restart: unless-stopped
    environment:
      DATABASE_URL: postgresql+asyncpg://postgres:postgres@postgres:5432/aicard
      PYTHONPATH: /app
    ports:
      - "8000:8000"
    depends_on:
      postgres:
        condition: service_healthy
    volumes:
      - ./api:/app
    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
  web:
    build:
      context: ./web
      dockerfile: Dockerfile
    restart: unless-stopped
    ports:
      - "3000:3000"
    depends_on:
      - api
    environment:
      - VITE_API_URL=http://api:8000
  # Cloudflare Tunnel (optional)
  cloudflared:
    image: cloudflare/cloudflared:latest
    restart: unless-stopped
    command: tunnel --no-autoupdate run
    environment:
      - TUNNEL_TOKEN=${CLOUDFLARE_TUNNEL_TOKEN}
    depends_on:
      - api
      - web
    profiles:
      - tunnel
 volumes:
  postgres_data:
--- a/docs/AI_CONTEXT.md
+++ b/docs/AI_CONTEXT.md
@@ -0,0 +1,285 @@
 # AI Context Document - ai.card プロジェクト
 > **重要**: このドキュメントは、将来のAI開発者（Claude Code等）が迅速にプロジェクトを理解し、作業を継続できるよう設計されています。
 ## 🎯 プロジェクト概要
 **ai.card** は、atprotoベースの分散型カードゲームです。ユーザーがデータを所有し、世界で一人だけが持てるuniqueカードが存在する革新的なシステムです。
 ### 中核思想
 - **存在子理論**: 世界の最小単位（ai）の探求がテーマ
 - **yui system**: 現実の個人とゲーム要素の1:1紐付け
 - **データ主権**: atproto PDSでユーザーがカードデータを所有
 - **現実の反映**: ゲームがプレイヤーの現実と連動
 ## 🏗️ システム構成
 ```
 [iOS App] ←→ [Web App] ←→ [FastAPI API] ←→ [PostgreSQL]
                                ↕
                         [atproto PDS]
                                ↕
                         [ai.verse(将来)]
 ```
 ### 技術スタック（2025年6月1日現在）
 - **Backend**: Python 3.11 + FastAPI + PostgreSQL + Docker
 - **Frontend**: React 18 + TypeScript + Vite + Framer Motion
 - **Mobile**: SwiftUI + Combine + iOS 16.0+
 - **Identity**: atproto DID + JWT
 - **Infrastructure**: Docker Compose + Cloudflare Tunnel + Supabase
 ## 💎 uniqueカードシステム（最重要概念）
 ### 概念
 ```
 通常のガチャ → キラカード(0.1%) → uniqueカード(0.0001%)
                     ↑表              ↑隠し機能
                 ユーザーの目標      偶然の幸運
 ```
 ### 実装
 - **確率**: 0.0001%（10万分の1）
 - **唯一性**: カードID 0-15の各種類につき、世界で1人のみ所有可能
 - **検証**: `unique_card_registry`テーブル + atproto PDS両方でチェック
 - **エフェクト**: 虹色オーラ + パーティクル + 特別UI
 ### データフロー
 ```
 ガチャ実行 → レアリティ判定 → unique可能性チェック → 
 atomic操作で確保 → DB保存 → atproto PDS同期 → アニメーション表示
 ```
 ## 🔐 atproto統合
 ### 認証フロー
 ```
 ユーザー: ハンドル + アプリパスワード
    ↓
 atproto PDS認証
    ↓
 JWT発行 → セッション管理
    ↓
 API呼び出し認証
 ```
 ### データ同期
 ```
 カード取得 → DB保存 → atproto collection record作成
    ↓
 レキシコン: ai.card.collection
    ↓
 ユーザーPDSにデータ保存（ユーザーがデータ所有）
 ```
 ## 📁 重要なファイル構造
 ### Backend（最重要）
 ```
 api/app/
 ├── models/card.py              # カードデータ定義
 ├── services/gacha.py           # ガチャロジック（uniqueカード生成）
 ├── services/atproto.py         # atproto統合
 ├── services/card_sync.py       # PDS同期
 ├── repositories/card.py        # カードデータアクセス
 ├── routes/auth.py              # 認証API
 ├── routes/cards.py             # カードAPI
 └── db/models.py                # データベースモデル
 ```
 ### Frontend
 ```
 web/src/
 ├── components/Card.tsx         # カード表示（エフェクト付き）
 ├── components/GachaAnimation.tsx # ガチャ演出
 ├── services/auth.ts            # 認証管理
 └── services/api.ts             # API通信
 ios/AiCard/AiCard/
 ├── Views/GachaView.swift       # ガチャ画面
 ├── Views/CardView.swift        # カード表示
 ├── Services/APIClient.swift    # API通信
 └── Services/AuthManager.swift  # 認証管理
 ```
 ## 🎮 ゲーム仕様
 ### カードマスター（16種類）
 ```json
 {
  "0": {"name": "アイ", "color": "fff700", "description": "世界の最小単位"},
  "1": {"name": "夢幻", "color": "b19cd9", "description": "意識が物質を作る"},
  ...
  "15": {"name": "世界", "color": "54a0ff", "description": "存在と世界は同じもの"}
 }
 ```
 ### レアリティ確率
 ```
 Normal: 99.789%      → グレー系
 Rare: 0.1%           → ブルー系
 Super Rare: 0.01%    → パープル系
 Kira: 0.1%           → ゴールド系（スパークル）
 Unique: 0.0001%      → マゼンタ系（オーラ）
 ```
 ## 🚀 開発環境セットアップ
 ### 1. 基本起動
 ```bash
 git clone [repository]
 cd ai.card
 # Docker環境起動
 docker-compose up -d
 # データベース初期化
 docker-compose exec api python init_db.py
 # Web開発サーバー
 cd web && npm install && npm run dev
 # iOS（Xcodeで開く）
 open ios/AiCard/AiCard.xcodeproj
 ```
 ### 2. 環境変数設定（.env）
 ```bash
 # PostgreSQL
 DATABASE_URL=postgresql+asyncpg://postgres:postgres@localhost:5432/aicard
 # atproto（テスト用）
 ATPROTO_HANDLE=test.bsky.social
 ATPROTO_PASSWORD=your-app-password
 # JWT
 SECRET_KEY=your-secret-key
 ```
 ### 3. atprotoアカウント準備
 1. Blueskyアカウント作成
 2. アプリパスワード生成（https://bsky.app/settings/app-passwords）
 3. 環境変数に設定
 ## 🔧 よくある実装パターン
 ### 1. 新しいAPIエンドポイント追加
 ```python
 # 1. routes/に新しいルート定義
@router.post("/new-endpoint")
 async def new_endpoint(db: AsyncSession = Depends(get_db)):
    # ロジック
 # 2. main.pyにルーター追加
 app.include_router(new_router, prefix=settings.api_v1_prefix)
 ```
 ### 2. データベーステーブル追加
 ```python
 # 1. db/models.pyに新しいモデル
 class NewModel(Base):
    __tablename__ = "new_table"
    # フィールド定義
 # 2. Alembicマイグレーション
 alembic revision --autogenerate -m "add new table"
 alembic upgrade head
 ```
 ### 3. atproto新機能追加
 ```python
 # services/atproto.pyに新しいメソッド
 async def new_atproto_feature(self, did: str, data: dict):
    # atproto SDK使用
    return self.client.some_new_api(data)
 ```
 ## 🎨 UI/UXパターン
 ### カードエフェクト実装
 ```typescript
 // Web（React + Framer Motion）
 <motion.div
  className={`card ${getRarityClass()}`}
  animate={isRevealing ? { rotateY: 0 } : {}}
  transition={{ duration: 0.8 }}
 >
 ```
 ```swift
 // iOS（SwiftUI）
 CardView(card: card)
    .rotation3DEffect(.degrees(isRevealing ? 0 : 180), axis: (0, 1, 0))
    .animation(.easeInOut(duration: 0.8), value: isRevealing)
 ```
 ## ⚠️ 重要な注意点
 ### 1. uniqueカードの整合性
 - **必須**: atomic操作でのunique確保
 - **必須**: DB + atproto PDS両方での検証
 - **注意**: レース条件の回避
 ### 2. atproto連携
 - **メインパスワード禁止**: 必ずアプリパスワード使用
 - **セッション管理**: JWTトークンの適切な管理
 - **エラーハンドリング**: atproto PDS接続失敗時の処理
 ### 3. 確率システム
 - **透明性**: 確率は隠さず設定ファイルで管理
 - **公平性**: サーバーサイドでの確率計算必須
 - **監査**: ガチャ履歴の完全記録
 ## 🔮 将来の拡張ポイント
 ### Phase 1: 運用安定化
 - 統合テスト自動化
 - モニタリング・アラート
 - パフォーマンス最適化
 ### Phase 2: 機能拡張
 - カード交換システム
 - プッシュ通知
 - リアルタイム同期
 ### Phase 3: エコシステム統合
 - ai.gpt連携（AI人格とカード連動）
 - ai.verse連携（3Dゲーム世界でunique skill）
 - 分散SNS連携
 ## 📋 デバッグ・トラブルシューティング
 ### よくある問題
 1. **ガチャでカードが生成されない**
   → `services/gacha.py`のエラーログ確認
 2. **atproto認証失敗**
   → アプリパスワードとハンドルの確認
 3. **uniqueカード重複**
   → `unique_card_registry`テーブルの整合性チェック
 4. **データベース接続失敗**
   → Docker Composeの起動状態確認
 ### ログ確認
 ```bash
 # API ログ
 docker-compose logs -f api
 # データベース状態
 docker-compose exec postgres psql -U postgres -d aicard -c "SELECT * FROM unique_card_registry;"
 ```
 ---
 ## 📚 推奨読み込み順序（AI向け）
 1. **このドキュメント全体** - プロジェクト概要把握
 2. **CLAUDE.md** - 哲学・思想の理解
 3. **IMPLEMENTATION_SUMMARY.md** - 具体的実装詳細
 4. **API.md** - APIエンドポイント仕様
 5. **DATABASE.md** - データベース設計
 6. **ATPROTO.md** - atproto連携詳細
 新しいAI開発者は、この順序で読むことで迅速にプロジェクトを理解し、作業を開始できます。
--- a/docs/API.md
+++ b/docs/API.md
@@ -0,0 +1,102 @@
 # ai.card API Documentation
 ## Base URL
 ```
 http://localhost:8000/api/v1
 ```
 ## Endpoints
 ### Draw Card
 カードを抽選します。
 ```
 POST /cards/draw
 ```
 #### Request Body
 ```json
 {
  "user_did": "did:plc:example123",
  "is_paid": false
 }
 ```
 #### Response
 ```json
 {
  "card": {
    "id": 0,
    "cp": 88,
    "status": "normal",
    "skill": null,
    "owner_did": "did:plc:example123",
    "obtained_at": "2025-01-01T00:00:00",
    "is_unique": false,
    "unique_id": null
  },
  "is_new": true,
  "animation_type": "normal"
 }
 ```
 ### Get User Cards
 ユーザーの所有カード一覧を取得します。
 ```
 GET /cards/user/{user_did}
 ```
 #### Response
 ```json
 [
  {
    "id": 0,
    "cp": 88,
    "status": "normal",
    "skill": null,
    "owner_did": "did:plc:example123",
    "obtained_at": "2025-01-01T00:00:00",
    "is_unique": false,
    "unique_id": null
  }
 ]
 ```
 ### Get Unique Cards
 全てのuniqueカード一覧を取得します。
 ```
 GET /cards/unique
 ```
 #### Response
 ```json
 [
  {
    "id": 8,
    "cp": 500,
    "status": "unique",
    "skill": "skill_8_unique",
    "owner_did": "did:plc:example123",
    "obtained_at": "2025-01-01T00:00:00",
    "is_unique": true,
    "unique_id": "550e8400-e29b-41d4-a716-446655440000"
  }
 ]
 ```
 ## Card Rarity
 - `normal`: 通常カード (99.789%)
 - `rare`: レアカード (0.1%)
 - `super_rare`: スーパーレアカード (0.01%)
 - `kira`: キラカード (0.1%)
 - `unique`: ユニークカード (0.0001%)
 ## Animation Types
 - `normal`: 通常演出
 - `rare`: レア演出
 - `kira`: キラカード演出
 - `unique`: ユニークカード演出（特別演出）
--- a/docs/ATPROTO.md
+++ b/docs/ATPROTO.md
@@ -0,0 +1,146 @@
 # atproto連携ガイド
 ## 概要
 ai.cardは、atproto（AT Protocol）と完全に統合されており、以下の機能を提供します：
 1. **atproto認証**: DIDベースの分散型認証
 2. **データ主権**: カードデータをユーザーのPDSに保存
 3. **相互運用性**: 他のatproto対応アプリとの連携
 ## 認証フロー
 ### 1. ログイン
 ```javascript
 // フロントエンド
 const response = await authService.login(identifier, password);
 // identifier: ハンドル（user.bsky.social）またはDID
 // password: アプリパスワード（メインパスワードではない）
 ```
 ### 2. アプリパスワードの作成
 1. https://bsky.app/settings/app-passwords にアクセス
 2. 新しいアプリパスワードを作成
 3. ai.cardでそのパスワードを使用
 ### 3. セッション管理
 - JWTトークンで24時間有効
 - Cookieとヘッダーの両方をサポート
 - 自動更新機能なし（再ログインが必要）
 ## データ保存
 ### カードコレクションのLexicon
 ```json
 {
  "lexicon": 1,
  "id": "ai.card.collection",
  "defs": {
    "main": {
      "type": "record",
      "record": {
        "type": "object",
        "properties": {
          "cardId": { "type": "integer" },
          "cp": { "type": "integer" },
          "status": { "type": "string" },
          "skill": { "type": "string" },
          "obtainedAt": { "type": "string" },
          "isUnique": { "type": "boolean" },
          "uniqueId": { "type": "string" }
        }
      }
    }
  }
 }
 ```
 ### データ同期
 ```bash
 # カードをPDSに同期
 POST /api/v1/sync/cards
 {
  "atproto_session": "session-string-from-login"
 }
 # PDSからインポート
 POST /api/v1/sync/import
 # PDSにエクスポート
 POST /api/v1/sync/export
 ```
 ## セキュリティ
 ### 1. 認証情報の取り扱い
 - **メインパスワードは使用しない**: 必ずアプリパスワードを使用
 - **セッション文字列の保護**: atprotoセッションは暗号化して保存
 - **HTTPS必須**: 本番環境では必ずHTTPS経由で通信
 ### 2. データ検証
 - サーバー側でカードデータの整合性をチェック
 - uniqueカードはグローバルレジストリで重複防止
 - PDSのデータも信頼せず、常に検証
 ### 3. 権限管理
 現在の制限：
 - ユーザーはPDSのデータを自由に編集可能
 - OAuth 2.1 scope実装待ち
 対策：
 - サーバー側検証で不正データを無効化
 - ゲームプレイ時は常にサーバーチェック
 ## APIエンドポイント
 ### 認証
 ```
 POST   /api/v1/auth/login      - ログイン
 POST   /api/v1/auth/logout     - ログアウト
 GET    /api/v1/auth/verify     - セッション確認
 POST   /api/v1/auth/verify-did - DID検証（公開）
 ```
 ### 同期
 ```
 POST   /api/v1/sync/cards      - 双方向同期
 POST   /api/v1/sync/export     - PDSへエクスポート
 POST   /api/v1/sync/import     - PDSからインポート
 GET    /api/v1/sync/verify/:id - カード所有確認
 ```
 ## トラブルシューティング
 ### ログインできない
 1. アプリパスワードを使用しているか確認
 2. ハンドルまたはDIDが正しいか確認
 3. PDSが稼働しているか確認
 ### データが同期されない
 1. atprotoセッションが有効か確認
 2. PDSの容量制限を確認
 3. ネットワーク接続を確認
 ### カードが表示されない
 1. `/api/v1/sync/import`でPDSからインポート
 2. ブラウザキャッシュをクリア
 3. 再ログイン
 ## 今後の予定
 1. **OAuth 2.1対応**: より細かい権限管理
 2. **リアルタイム同期**: WebSocketでの即時反映
 3. **他アプリ連携**: atprotoエコシステムとの統合
--- a/docs/DATABASE.md
+++ b/docs/DATABASE.md
@@ -0,0 +1,102 @@
 # データベース設定ガイド
 ## ローカル開発（Docker Compose）
 ### 1. 起動
 ```bash
 # データベースとAPIを起動
 docker-compose up -d
 # ログを確認
 docker-compose logs -f
 ```
 ### 2. データベース初期化
 ```bash
 # APIコンテナに入る
 docker-compose exec api bash
 # マイグレーション実行
 alembic upgrade head
 # マスタデータ投入
 python init_db.py
 ```
 ## Supabase連携
 ### 1. Supabaseプロジェクト作成
 1. [Supabase](https://supabase.com)でプロジェクト作成
 2. Settings > Database から接続情報を取得
 ### 2. 環境変数設定
 ```bash
 # .env
 DATABASE_URL_SUPABASE=postgresql+asyncpg://postgres.[project-ref]:[password]@aws-0-[region].pooler.supabase.com:5432/postgres
 USE_SUPABASE=true
 ```
 ### 3. テーブル作成
 Supabase SQL Editorで以下を実行：
 ```sql
 -- Alembicのマイグレーションを実行
 -- または直接SQLでテーブル作成
 ```
 ## Cloudflare Tunnel設定
 ### 1. トンネル作成
 ```bash
 # Cloudflareダッシュボードでトンネル作成
 # トークンを取得
 ```
 ### 2. 環境変数設定
 ```bash
 # .env
 CLOUDFLARE_TUNNEL_TOKEN=your-tunnel-token
 ```
 ### 3. 起動
 ```bash
 # tunnelプロファイルを含めて起動
 docker-compose --profile tunnel up -d
 ```
 ## データベーススキーマ
 ### users
 - ユーザー情報（DID、ハンドル）
 ### card_master
 - カードマスタデータ（16種類）
 ### user_cards
 - ユーザー所有カード
 - uniqueカードフラグ付き
 ### unique_card_registry
 - グローバルuniqueカード登録
 - 各カードIDにつき1人のみ所有可能
 ### draw_history
 - ガチャ履歴
 ### gacha_pools
 - ピックアップガチャ設定
 ## バックアップ
 ### ローカル
 ```bash
 # バックアップ
 docker-compose exec postgres pg_dump -U postgres aicard > backup.sql
 # リストア
 docker-compose exec -T postgres psql -U postgres aicard < backup.sql
 ```
 ### Supabase
 - 自動バックアップが有効
 - ダッシュボードからダウンロード可能
--- a/docs/DEVELOPMENT.md
+++ b/docs/DEVELOPMENT.md
@@ -0,0 +1,124 @@
 # 開発ガイド
 ## セットアップ
 ### 1. API (FastAPI)
 ```bash
 cd api
 # 仮想環境作成
 python -m venv venv
 source venv/bin/activate  # macOS/Linux
 # or
 venv\Scripts\activate  # Windows
 # 依存関係インストール
 pip install -r requirements.txt
 # 環境変数設定
 cp .env.example .env
 # .envを編集
 # 開発サーバー起動
 uvicorn app.main:app --reload
 ```
 APIは http://localhost:8000 で起動します。
 APIドキュメントは http://localhost:8000/docs で確認できます。
 ### 2. Web (React + Vite)
 ```bash
 cd web
 # 依存関係インストール
 npm install
 # 開発サーバー起動
 npm run dev
 ```
 Webアプリは http://localhost:3000 で起動します。
 ## プロジェクト構造
 ```
 ai.card/
 ├── api/                    # FastAPI backend
 │   ├── app/
 │   │   ├── core/          # 設定、共通処理
 │   │   ├── models/        # Pydanticモデル
 │   │   ├── routes/        # APIエンドポイント
 │   │   ├── services/      # ビジネスロジック
 │   │   └── main.py        # アプリケーションエントリ
 │   └── requirements.txt
 │
 ├── web/                    # React frontend
 │   ├── src/
 │   │   ├── components/    # Reactコンポーネント
 │   │   ├── services/      # API通信
 │   │   ├── styles/        # CSS
 │   │   ├── types/         # TypeScript型定義
 │   │   └── App.tsx        # メインコンポーネント
 │   └── package.json
 │
 ├── ios/                    # iOS app (今後実装)
 └── docs/                   # ドキュメント
 ```
 ## 技術スタック
 ### Backend
 - Python 3.9+
 - FastAPI
 - Pydantic
 - SQLAlchemy (今後実装)
 - atproto SDK
 ### Frontend
 - React 18
 - TypeScript
 - Vite
 - Framer Motion (アニメーション)
 - Axios
 ## 開発のポイント
 ### 1. カードデータ
 カードは0-15のIDを持ち、ai.jsonの定義に基づいています。
 ### 2. レアリティシステム
 - 通常のガチャではキラカードが最高レア
 - uniqueカードは隠し要素として実装
 - 確率は設定ファイルで調整可能
 ### 3. atproto連携
 - ユーザー認証はatproto OAuth（今後実装）
 - カードデータはユーザーのPDSに保存（今後実装）
 - 現在はローカルストレージのみ
 ### 4. アニメーション
 - ガチャ演出はレアリティに応じて変化
 - uniqueカードは特別な演出
 - Framer Motionで実装
 ## 今後の実装予定
 1. **データベース連携**
   - SQLAlchemyでのモデル定義
   - ユーザーごとのカード管理
 2. **atproto統合**
   - OAuth認証
   - PDSへのデータ保存
   - DID検証
 3. **uniqueカード検証**
   - グローバルレジストリ
   - 重複チェック
   - ai.verse連携
 4. **iOS app**
   - SwiftUIで実装
   - 共通APIを使用
--- a/docs/IMPLEMENTATION_SUMMARY.md
+++ b/docs/IMPLEMENTATION_SUMMARY.md
@@ -0,0 +1,267 @@
 # ai.card 実装完了サマリー
 ## 作業日: 2025年6月1日
 ### 📋 今日実装した内容
 ## 1. データベース実装（PostgreSQL + Supabase）
 ### 完成機能
 - **PostgreSQLスキーマ設計**: 7つのテーブル（users, card_master, user_cards, unique_card_registry等）
 - **Docker Compose環境**: 開発・本番両対応
 - **Supabase連携**: 環境変数で切り替え可能
 - **リポジトリパターン**: BaseRepository + 専用Repository
 - **マイグレーション**: Alembic設定 + 初期データ投入
 - **データ同期**: ガチャ時の自動データベース保存
 ### 重要ファイル
 ```
 api/app/db/models.py         # SQLAlchemyモデル
 api/app/repositories/        # リポジトリパターン実装
 api/init_db.py              # データベース初期化
 docker-compose.yml          # 開発環境
 docker-compose.production.yml # 本番環境
 ```
 ## 2. atproto連携機能
 ### 完成機能
 - **認証システム**: DID/ハンドルログイン + JWTトークン
 - **PDSデータ保存**: カードをユーザーのPDSに自動同期
 - **Lexicon定義**: `ai.card.collection` スキーマ
 - **同期API**: 双方向同期・インポート・エクスポート
 - **データ検証**: サーバー側整合性チェック
 ### 重要ファイル
 ```
 api/app/services/atproto.py     # atproto統合サービス
 api/app/services/card_sync.py   # カード同期サービス
 api/app/routes/auth.py          # 認証API
 api/app/routes/sync.py          # 同期API
 api/app/auth/dependencies.py    # 認証依存関係
 ```
 ## 3. iOS App完全実装
 ### 完成機能
 - **SwiftUI + MVVM**: Combineを使ったリアクティブアーキテクチャ
 - **認証画面**: atprotoログイン（アプリパスワード対応）
 - **ガチャシステム**: 通常・プレミアムガチャ + リッチアニメーション
 - **カードコレクション**: グリッド表示・検索・フィルタ・詳細画面
 - **プロフィール**: ユーザー情報・統計・設定
 - **視覚エフェクト**: レアリティ別アニメーション・3Dフリップ
 ### 重要ファイル
 ```
 ios/AiCard/AiCard/
 ├── Models/Card.swift           # カードデータモデル
 ├── Services/APIClient.swift    # API通信（Combine使用）
 ├── Services/AuthManager.swift  # 認証管理
 ├── Services/CardManager.swift  # カード管理
 ├── Views/LoginView.swift       # ログイン画面
 ├── Views/GachaView.swift       # ガチャ画面
 ├── Views/CollectionView.swift  # コレクション画面
 ├── Views/CardView.swift        # カード表示コンポーネント
 └── Views/GachaAnimationView.swift # ガチャアニメーション
 ```
 ## 4. プロジェクト統合
 ### アーキテクチャ概要
 ```
 [iOS App] ←→ [Web App] ←→ [FastAPI] ←→ [PostgreSQL]
                               ↕
                          [atproto PDS]
 ```
 ### データフロー
 1. **ガチャ**: iOS/Web → API → DB保存 → atproto PDS同期
 2. **認証**: atproto DID → JWT → セッション管理
 3. **同期**: DB ↔ atproto PDS双方向同期
 ## 📊 実装済み機能一覧
 ### ✅ Backend (FastAPI)
 - [x] PostgreSQL + Supabase対応
 - [x] atproto認証・同期
 - [x] ガチャシステム（確率・unique管理）
 - [x] カードCRUD API
 - [x] Docker環境（開発・本番）
 - [x] リポジトリパターン
 - [x] データベースマイグレーション
 ### ✅ Frontend (React)
 - [x] atproto認証UI
 - [x] ガチャアニメーション（Framer Motion）
 - [x] カード表示・コレクション
 - [x] レスポンシブデザイン
 - [x] TypeScript対応
 ### ✅ Mobile (iOS)
 - [x] SwiftUI + MVVM + Combine
 - [x] atproto認証
 - [x] ガチャ（通常・プレミアム）
 - [x] カードコレクション（検索・フィルタ）
 - [x] リッチアニメーション
 - [x] iOS 16.0+ 対応
 ### ✅ DevOps
 - [x] Docker Compose
 - [x] Cloudflare Tunnel対応
 - [x] 環境別設定
 - [x] ヘルスチェック
 ## 🔧 技術スタック
 ### Backend
 - **Language**: Python 3.11
 - **Framework**: FastAPI 0.104.1
 - **Database**: PostgreSQL + SQLAlchemy
 - **ORM**: SQLAlchemy 2.0 (async)
 - **Migration**: Alembic
 - **Cloud**: Supabase対応
 - **atproto**: atproto SDK 0.0.46
 ### Frontend (Web)
 - **Language**: TypeScript
 - **Framework**: React 18 + Vite
 - **Animation**: Framer Motion
 - **HTTP**: Axios
 - **Styling**: CSS Modules
 ### Mobile (iOS)
 - **Language**: Swift 5.7+
 - **Framework**: SwiftUI
 - **Architecture**: MVVM + Combine
 - **HTTP**: URLSession
 - **Minimum**: iOS 16.0
 ### Infrastructure
 - **Container**: Docker + Docker Compose
 - **Proxy**: Nginx
 - **Tunnel**: Cloudflare Tunnel
 - **Database**: PostgreSQL 16
 ## 🎯 unique カードシステムの実装
 ### 概念
 - **確率**: 0.0001%（10万分の1）
 - **唯一性**: 各カードID（0-15）につき世界で1人のみ所有可能
 - **検証**: サーバー側 + atproto PDS両方でチェック
 - **将来**: ai.verse unique skillとの連携予定
 ### 実装詳細
 - `unique_card_registry`テーブルでグローバル管理
 - ガチャ時にatomic操作で重複防止
 - atproto PDSにも同期保存
 - Web/iOSで特別なエフェクト表示
 ## 🚀 デプロイメント準備
 ### 開発環境起動
 ```bash
 # 全体起動
 docker-compose up -d
 # データベース初期化
 docker-compose exec api python init_db.py
 # Web開発サーバー
 cd web && npm run dev
 # iOS（Xcodeで開く）
 open ios/AiCard/AiCard.xcodeproj
 ```
 ### 本番環境起動
 ```bash
 # 本番設定で起動
 docker-compose -f docker-compose.production.yml up -d
 ```
 ## 📝 重要な設定ファイル
 ### 環境変数（.env）
 ```bash
 # Database
 DATABASE_URL=postgresql+asyncpg://postgres:postgres@localhost:5432/aicard
 DATABASE_URL_SUPABASE=postgresql+asyncpg://...
 USE_SUPABASE=false
 # atproto
 ATPROTO_HANDLE=your.bsky.social
 ATPROTO_PASSWORD=your-app-password
 # Security
 SECRET_KEY=your-secret-key
 # Cloudflare Tunnel
 CLOUDFLARE_TUNNEL_TOKEN=your-tunnel-token
 ```
 ### API設定
 - **開発**: `http://localhost:8000`
 - **本番**: `https://api.card.syui.ai`
 - **認証**: Bearer JWT token
 - **CORS**: Web/iOS対応
 ## 🔮 今後の実装候補
 ### Phase 1: 運用準備
 - [ ] 統合テスト（全システム連携）
 - [ ] パフォーマンス最適化
 - [ ] モニタリング・ログ
 - [ ] セキュリティ監査
 ### Phase 2: 機能拡張
 - [ ] カード交換システム
 - [ ] プッシュ通知（iOS）
 - [ ] リアルタイム同期（WebSocket）
 - [ ] バックアップ・復元
 ### Phase 3: エコシステム統合
 - [ ] ai.gpt連携
 - [ ] ai.verse unique skill連携
 - [ ] yui system実装
 - [ ] 分散SNS連携
 ## 🎮 ゲーム仕様
 ### カードシステム
 - **種類**: 16種類（ai, 夢幻, 光彩, 中性子, 太陽, 夜空, 雪, 雷, 超究, 剣, 破壊, 地球, 天の川, 創造, 超新星, 世界）
 - **CP**: 1-999（レアリティでボーナス）
 - **レアリティ**: 5段階（normal, rare, super_rare, kira, unique）
 ### ガチャ確率
 - **Normal**: 99.789%
 - **Rare**: 0.1%
 - **Super Rare**: 0.01%
 - **Kira**: 0.1%
 - **Unique**: 0.0001%（隠し機能）
 ### 演出
 - **Web**: CSS + Framer Motion
 - **iOS**: SwiftUI Animation + Particle Effects
 - **レアリティ別**: 色・エフェクト・音（予定）
 ---
 ## 💡 AI向けメモ
 ### プロジェクト理解のキーポイント
 1. **存在子理論**: 最小単位の意識がゲーム世界の根幹
 2. **yui system**: 現実の個人とゲーム内要素の1:1紐付け
 3. **データ主権**: atproto PDSでユーザーがデータを所有
 4. **uniqueカード**: NFT的だがブロックチェーン不使用
 ### 重要な実装パターン
 - **リポジトリパターン**: データアクセス層の抽象化
 - **atproto同期**: ガチャ時の自動PDS保存
 - **レアリティシステム**: 確率とエフェクトの連動
 - **認証フロー**: DID → JWT → セッション管理
 ### 次回作業時の注意点
 - 環境変数の設定確認
 - データベースの初期化
 - atprotoアカウントの準備
 - Docker環境の起動確認
--- a/docs/MCP_INTEGRATION_SUMMARY.md
+++ b/docs/MCP_INTEGRATION_SUMMARY.md
@@ -0,0 +1,129 @@
 # ai.card MCP Server統合作業報告 (2025/01/06)
 ## 作業概要
 ai.cardプロジェクトに独立したMCPサーバーを実装し、FastAPIベースのカードゲームAPIをMCPツールとして公開。
 ## 実装内容
 ### 1. 依存関係の解決
 **課題と対応:**
 - `atproto==0.0.46` → `atproto>=0.0.55` (Python 3.13対応)
 - `httpx` バージョン競合 → supabase一時無効化
 - `pydantic==2.5.0` → `pydantic>=2.7.0` (atproto要件)
 - PostgreSQL依存 → SQLiteベースに変更
 - `greenlet` 追加 (SQLAlchemy非同期処理)
 **最終的な依存関係:**
 ```txt
 fastapi>=0.104.1
 uvicorn[standard]>=0.24.0
 pydantic>=2.7.0,<3.0.0
 sqlalchemy>=2.0.23
 greenlet>=3.0.0
 aiosqlite>=0.19.0
 fastapi-mcp==0.1.0
 atproto>=0.0.55
 # supabase>=2.3.0  # httpx競合のため無効化
 # asyncpg, psycopg2-binary  # コンパイル回避のため無効化
 ```
 ### 2. MCP Server実装
 **ファイル:** `api/app/mcp_server.py`
 **主要変更:**
 - `from mcp.server.fastmcp import FastMCP` (正しいインポート)
 - `FastMCP("aicard")` で初期化
 - 9個のMCPツール実装
 **公開ツール:**
 1. `get_user_cards` - ユーザーカード一覧
 2. `draw_card` - ガチャ実行  
 3. `get_card_details` - カード詳細情報
 4. `analyze_card_collection` - コレクション分析
 5. `get_unique_registry` - ユニークカード登録状況
 6. `sync_cards_atproto` - atproto同期（無効化中）
 7. `get_gacha_stats` - ガチャ統計
 ### 3. データベース設定
 **SQLite使用:**
 - 場所: `~/.config/syui/ai/card/aicard.db`
 - 理由: 依存関係シンプル化、開発環境最適化
 - PostgreSQL移行: 将来的にDocker利用で対応
 ### 4. 補助スクリプト
 - `setup_venv.sh` - 仮想環境セットアップ
 - `start_server.sh` - サーバー起動スクリプト
 - `docker-compose.dev.yml` - PostgreSQL開発環境
 ## 既知の問題と対応
 ### 解決済み
 - ✅ fastapi-mcp インポートエラー → 正しいパッケージ名に修正
 - ✅ get_db → get_session 関数名不一致
 - ✅ Optional型インポート漏れ
 - ✅ SQLAlchemy greenlet依存
 - ✅ データベース初期化エラー
 ### 未解決（将来対応）
 - atproto SessionString APIの変更
 - supabase httpxバージョン競合
 - ガチャ確率計算の精度問題
 ## 環境セットアップ手順
 ### 1. 仮想環境構築
 ```bash
 cd /Users/syui/ai/gpt/card
 ./setup_venv.sh
 ```
 ### 2. データベース初期化
 ```bash
 cd api
 ~/.config/syui/ai/card/venv/bin/python init_db.py
 ```
 ### 3. サーバー起動
 ```bash
 ./start_server.sh
 # または
 cd api
 ~/.config/syui/ai/card/venv/bin/python -m app.main
 ```
 ### 4. 動作確認
 ```bash
 # ヘルスチェック
 curl http://localhost:8000/health
 # API仕様書
 open http://localhost:8000/docs
 # カード取得テスト
 curl -X POST "http://localhost:8000/draw_card?did=did:plc:test123"
 ```
 ## PostgreSQL移行（将来）
 ### Docker開発環境
 ```bash
 # PostgreSQLのみ起動
 docker-compose -f docker-compose.dev.yml up -d
 # 環境変数設定
 export DATABASE_URL="postgresql+asyncpg://postgres:postgres@localhost:5432/aicard"
 # APIサーバー起動
 ./start_server.sh
 ```
 ### 本番環境
 - iOS/Webアプリ → PostgreSQL必須
 - Docker Composeで全サービス管理
 - Cloudflare Tunnel経由で公開
 ## 成果
 - ai.card独立MCPサーバー稼働
 - SQLiteベースで依存関係問題解決
 - 自動リロード対応の開発環境構築
 - iOS/Web連携準備完了
--- a/ios/AiCard/AiCard.xcodeproj/project.pbxproj
+++ b/ios/AiCard/AiCard.xcodeproj/project.pbxproj
@@ -0,0 +1,330 @@
 // !$*UTF8*$!
 {
 	archiveVersion = 1;
 	classes = {
 	};
 	objectVersion = 56;
 	objects = {
 /* Begin PBXBuildFile section */
 		1A1234561234567890ABCDEF /* AiCardApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A1234551234567890ABCDEF /* AiCardApp.swift */; };
 		1A1234581234567890ABCDEF /* ContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A1234571234567890ABCDEF /* ContentView.swift */; };
 		1A12345A1234567890ABCDEF /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 1A1234591234567890ABCDEF /* Assets.xcassets */; };
 /* End PBXBuildFile section */
 /* Begin PBXFileReference section */
 		1A1234521234567890ABCDEF /* AiCard.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = AiCard.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		1A1234551234567890ABCDEF /* AiCardApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AiCardApp.swift; sourceTree = "<group>"; };
 		1A1234571234567890ABCDEF /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = "<group>"; };
 		1A1234591234567890ABCDEF /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 /* Begin PBXFrameworksBuildPhase section */
 		1A12344F1234567890ABCDEF /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXFrameworksBuildPhase section */
 /* Begin PBXGroup section */
 		1A1234491234567890ABCDEF = {
 			isa = PBXGroup;
 			children = (
 				1A1234541234567890ABCDEF /* AiCard */,
 				1A1234531234567890ABCDEF /* Products */,
 			);
 			sourceTree = "<group>";
 		};
 		1A1234531234567890ABCDEF /* Products */ = {
 			isa = PBXGroup;
 			children = (
 				1A1234521234567890ABCDEF /* AiCard.app */,
 			);
 			name = Products;
 			sourceTree = "<group>";
 		};
 		1A1234541234567890ABCDEF /* AiCard */ = {
 			isa = PBXGroup;
 			children = (
 				1A1234551234567890ABCDEF /* AiCardApp.swift */,
 				1A1234571234567890ABCDEF /* ContentView.swift */,
 				1A1234591234567890ABCDEF /* Assets.xcassets */,
 			);
 			path = AiCard;
 			sourceTree = "<group>";
 		};
 /* End PBXGroup section */
 /* Begin PBXNativeTarget section */
 		1A1234511234567890ABCDEF /* AiCard */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 1A1234601234567890ABCDEF /* Build configuration list for PBXNativeTarget "AiCard" */;
 			buildPhases = (
 				1A12344E1234567890ABCDEF /* Sources */,
 				1A12344F1234567890ABCDEF /* Frameworks */,
 				1A1234501234567890ABCDEF /* Resources */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 			);
 			name = AiCard;
 			productName = AiCard;
 			productReference = 1A1234521234567890ABCDEF /* AiCard.app */;
 			productType = "com.apple.product-type.application";
 		};
 /* End PBXNativeTarget section */
 /* Begin PBXProject section */
 		1A12344A1234567890ABCDEF /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
 				BuildIndependentTargetsInParallel = 1;
 				LastSwiftUpdateCheck = 1500;
 				LastUpgradeCheck = 1500;
 				TargetAttributes = {
 					1A1234511234567890ABCDEF = {
 						CreatedOnToolsVersion = 15.0;
 					};
 				};
 			};
 			buildConfigurationList = 1A12344D1234567890ABCDEF /* Build configuration list for PBXProject "AiCard" */;
 			compatibilityVersion = "Xcode 14.0";
 			developmentRegion = en;
 			hasScannedForEncodings = 0;
 			knownRegions = (
 				en,
 				Base,
 			);
 			mainGroup = 1A1234491234567890ABCDEF;
 			productRefGroup = 1A1234531234567890ABCDEF /* Products */;
 			projectDirPath = "";
 			projectRoot = "";
 			targets = (
 				1A1234511234567890ABCDEF /* AiCard */,
 			);
 		};
 /* End PBXProject section */
 /* Begin PBXResourcesBuildPhase section */
 		1A1234501234567890ABCDEF /* Resources */ = {
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				1A12345A1234567890ABCDEF /* Assets.xcassets in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXResourcesBuildPhase section */
 /* Begin PBXSourcesBuildPhase section */
 		1A12344E1234567890ABCDEF /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				1A1234581234567890ABCDEF /* ContentView.swift in Sources */,
 				1A1234561234567890ABCDEF /* AiCardApp.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXSourcesBuildPhase section */
 /* Begin XCBuildConfiguration section */
 		1A12345E1234567890ABCDEF /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
 				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
 				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
 				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_OPTIMIZATION_LEVEL = 0;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"DEBUG=1",
 					"$(inherited)",
 				);
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
 				GCC_WARN_UNDECLARED_SELECTOR = YES;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
 			};
 			name = Debug;
 		};
 		1A12345F1234567890ABCDEF /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
 				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
 				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
 				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
 				GCC_WARN_UNDECLARED_SELECTOR = YES;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				SDKROOT = iphoneos;
 				SWIFT_COMPILATION_MODE = wholemodule;
 				SWIFT_OPTIMIZATION_LEVEL = "-O";
 				VALIDATE_PRODUCT = YES;
 			};
 			name = Release;
 		};
 		1A1234611234567890ABCDEF /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 1;
 				DEVELOPMENT_ASSET_PATHS = "";
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES;
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
 				MARKETING_VERSION = 1.0;
 				PRODUCT_BUNDLE_IDENTIFIER = ai.syui.card;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
 		};
 		1A1234621234567890ABCDEF /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 1;
 				DEVELOPMENT_ASSET_PATHS = "";
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES;
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
 				MARKETING_VERSION = 1.0;
 				PRODUCT_BUNDLE_IDENTIFIER = ai.syui.card;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Release;
 		};
 /* End XCBuildConfiguration section */
 /* Begin XCConfigurationList section */
 		1A12344D1234567890ABCDEF /* Build configuration list for PBXProject "AiCard" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				1A12345E1234567890ABCDEF /* Debug */,
 				1A12345F1234567890ABCDEF /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		1A1234601234567890ABCDEF /* Build configuration list for PBXNativeTarget "AiCard" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				1A1234611234567890ABCDEF /* Debug */,
 				1A1234621234567890ABCDEF /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 /* End XCConfigurationList section */
 	};
 	rootObject = 1A12344A1234567890ABCDEF /* Project object */;
 }
--- a/ios/AiCard/AiCard/AiCardApp.swift
+++ b/ios/AiCard/AiCard/AiCardApp.swift
@@ -0,0 +1,16 @@
 import SwiftUI
@main
 struct AiCardApp: App {
    @StateObject private var authManager = AuthManager()
    @StateObject private var cardManager = CardManager()
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(authManager)
                .environmentObject(cardManager)
                .preferredColorScheme(.dark)
        }
    }
 }
--- a/ios/AiCard/AiCard/ContentView.swift
+++ b/ios/AiCard/AiCard/ContentView.swift
@@ -0,0 +1,41 @@
 import SwiftUI
 struct ContentView: View {
    @EnvironmentObject var authManager: AuthManager
    @State private var selectedTab = 0
    var body: some View {
        if authManager.isAuthenticated {
            TabView(selection: $selectedTab) {
                GachaView()
                    .tabItem {
                        Label("ガチャ", systemImage: "sparkles")
                    }
                    .tag(0)
                CollectionView()
                    .tabItem {
                        Label("コレクション", systemImage: "square.grid.3x3")
                    }
                    .tag(1)
                ProfileView()
                    .tabItem {
                        Label("プロフィール", systemImage: "person.circle")
                    }
                    .tag(2)
            }
            .accentColor(Color(hex: "fff700"))
        } else {
            LoginView()
        }
    }
 }
 struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
            .environmentObject(AuthManager())
            .environmentObject(CardManager())
    }
 }
--- a/ios/AiCard/AiCard/Models/AIModels.swift
+++ b/ios/AiCard/AiCard/Models/AIModels.swift
@@ -0,0 +1,73 @@
 import Foundation
 // MARK: - AI分析関連モデル
 struct CollectionAnalysis: Codable {
    let totalCards: Int
    let uniqueCards: Int
    let rarityDistribution: [String: Int]
    let collectionScore: Double
    let recommendations: [String]
    enum CodingKeys: String, CodingKey {
        case totalCards = "total_cards"
        case uniqueCards = "unique_cards"
        case rarityDistribution = "rarity_distribution"
        case collectionScore = "collection_score"
        case recommendations
    }
 }
 struct GachaStats: Codable {
    let totalDraws: Int
    let cardsByRarity: [String: Int]
    let successRates: [String: Double]
    let recentActivity: [GachaActivity]
    enum CodingKeys: String, CodingKey {
        case totalDraws = "total_draws"
        case cardsByRarity = "cards_by_rarity"
        case successRates = "success_rates"
        case recentActivity = "recent_activity"
    }
 }
 struct GachaActivity: Codable {
    let timestamp: String
    let userDid: String
    let cardName: String
    let rarity: String
    enum CodingKeys: String, CodingKey {
        case timestamp
        case userDid = "user_did"
        case cardName = "card_name"
        case rarity
    }
 }
 struct UniqueRegistry: Codable {
    let registeredCards: [String: String]
    let totalUnique: Int
    enum CodingKeys: String, CodingKey {
        case registeredCards = "registered_cards"
        case totalUnique = "total_unique"
    }
 }
 struct SystemStatus: Codable {
    let status: String
    let mcpEnabled: Bool
    let mcpEndpoint: String?
    let databaseConnected: Bool
    let aiGptConnected: Bool
    enum CodingKeys: String, CodingKey {
        case status
        case mcpEnabled = "mcp_enabled"
        case mcpEndpoint = "mcp_endpoint"
        case databaseConnected = "database_connected"
        case aiGptConnected = "ai_gpt_connected"
    }
 }
--- a/ios/AiCard/AiCard/Models/Card.swift
+++ b/ios/AiCard/AiCard/Models/Card.swift
@@ -0,0 +1,90 @@
 import Foundation
 enum CardRarity: String, Codable, CaseIterable {
    case normal = "normal"
    case rare = "rare"
    case superRare = "super_rare"
    case kira = "kira"
    case unique = "unique"
    var displayName: String {
        switch self {
        case .normal: return "ノーマル"
        case .rare: return "レア"
        case .superRare: return "スーパーレア"
        case .kira: return "キラ"
        case .unique: return "ユニーク"
        }
    }
    var gradientColors: [String] {
        switch self {
        case .normal: return ["666666", "333333"]
        case .rare: return ["4a90e2", "16213e"]
        case .superRare: return ["9c27b0", "0f0c29"]
        case .kira: return ["ffd700", "414345"]
        case .unique: return ["ff00ff", "1a0033"]
        }
    }
 }
 struct Card: Identifiable, Codable {
    let id: Int
    let cp: Int
    let status: CardRarity
    let skill: String?
    let ownerDid: String
    let obtainedAt: Date
    let isUnique: Bool
    let uniqueId: String?
    private enum CodingKeys: String, CodingKey {
        case id
        case cp
        case status
        case skill
        case ownerDid = "owner_did"
        case obtainedAt = "obtained_at"
        case isUnique = "is_unique"
        case uniqueId = "unique_id"
    }
 }
 struct CardDrawResult: Codable {
    let card: Card
    let isNew: Bool
    let animationType: String
    private enum CodingKeys: String, CodingKey {
        case card
        case isNew = "is_new"
        case animationType = "animation_type"
    }
 }
 // Card master data
 struct CardInfo {
    let id: Int
    let name: String
    let color: String
    let description: String
    static let all: [Int: CardInfo] = [
        0: CardInfo(id: 0, name: "アイ", color: "fff700", description: "世界の最小単位"),
        1: CardInfo(id: 1, name: "夢幻", color: "b19cd9", description: "意識が物質を作る"),
        2: CardInfo(id: 2, name: "光彩", color: "ffd700", description: "存在は光に向かう"),
        3: CardInfo(id: 3, name: "中性子", color: "cacfd2", description: "中性子"),
        4: CardInfo(id: 4, name: "太陽", color: "ff6b35", description: "太陽"),
        5: CardInfo(id: 5, name: "夜空", color: "1a1a2e", description: "夜空"),
        6: CardInfo(id: 6, name: "雪", color: "e3f2fd", description: "雪"),
        7: CardInfo(id: 7, name: "雷", color: "ffd93d", description: "雷"),
        8: CardInfo(id: 8, name: "超究", color: "6c5ce7", description: "超究"),
        9: CardInfo(id: 9, name: "剣", color: "a8e6cf", description: "剣"),
        10: CardInfo(id: 10, name: "破壊", color: "ff4757", description: "破壊"),
        11: CardInfo(id: 11, name: "地球", color: "4834d4", description: "地球"),
        12: CardInfo(id: 12, name: "天の川", color: "9c88ff", description: "天の川"),
        13: CardInfo(id: 13, name: "創造", color: "00d2d3", description: "創造"),
        14: CardInfo(id: 14, name: "超新星", color: "ff9ff3", description: "超新星"),
        15: CardInfo(id: 15, name: "世界", color: "54a0ff", description: "存在と世界は同じもの")
    ]
 }
--- a/ios/AiCard/AiCard/Models/User.swift
+++ b/ios/AiCard/AiCard/Models/User.swift
@@ -0,0 +1,25 @@
 import Foundation
 struct User: Codable {
    let did: String
    let handle: String
 }
 struct LoginRequest: Codable {
    let identifier: String
    let password: String
 }
 struct LoginResponse: Codable {
    let accessToken: String
    let tokenType: String
    let did: String
    let handle: String
    private enum CodingKeys: String, CodingKey {
        case accessToken = "access_token"
        case tokenType = "token_type"
        case did
        case handle
    }
 }
--- a/ios/AiCard/AiCard/Services/APIClient.swift
+++ b/ios/AiCard/AiCard/Services/APIClient.swift
@@ -0,0 +1,237 @@
 import Foundation
 import Combine
 enum APIError: Error {
    case invalidURL
    case noData
    case decodingError
    case networkError(String)
    case unauthorized
 }
 // MCP Server response format
 struct MCPResponse<T: Decodable>: Decodable {
    let data: T?
    let error: String?
 }
 class APIClient {
    static let shared = APIClient()
    #if DEBUG
    private let baseURL = "http://localhost:8000/api/v1"  // ai.card direct access
    private let aiGptBaseURL = "http://localhost:8001"    // ai.gpt MCP server (optional)
    #else
    private let baseURL = "https://api.card.syui.ai/api/v1"  // ai.card direct access
    private let aiGptBaseURL = "https://ai.gpt.syui.ai"    // ai.gpt MCP server (optional)
    #endif
    private var cancellables = Set<AnyCancellable>()
    private init() {}
    private var authToken: String? {
        get { UserDefaults.standard.string(forKey: "authToken") }
        set { UserDefaults.standard.set(newValue, forKey: "authToken") }
    }
    // ai.gpt MCP経由でのリクエスト（推奨）
    private func mcpRequest<T: Decodable>(_ endpoint: String,
                                         parameters: [String: Any] = [:]) -> AnyPublisher<T, APIError> {
        guard let url = URL(string: "\(aiGptBaseURL)\(endpoint)") else {
            return Fail(error: APIError.invalidURL).eraseToAnyPublisher()
        }
        var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
        components?.queryItems = parameters.map { URLQueryItem(name: $0.key, value: "\($0.value)") }
        guard let finalURL = components?.url else {
            return Fail(error: APIError.invalidURL).eraseToAnyPublisher()
        }
        var request = URLRequest(url: finalURL)
        request.httpMethod = "GET"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        return URLSession.shared.dataTaskPublisher(for: request)
            .tryMap { data, response in
                guard let httpResponse = response as? HTTPURLResponse else {
                    throw APIError.networkError("Invalid response")
                }
                if !(200...299).contains(httpResponse.statusCode) {
                    throw APIError.networkError("MCP Server error: \(httpResponse.statusCode)")
                }
                return data
            }
            .decode(type: MCPResponse<T>.self, decoder: JSONDecoder())
            .tryMap { mcpResponse in
                if let data = mcpResponse.data {
                    return data
                } else if let error = mcpResponse.error {
                    throw APIError.networkError(error)
                } else {
                    throw APIError.networkError("Invalid MCP response")
                }
            }
            .mapError { error in
                if error is DecodingError {
                    return APIError.decodingError
                } else if let apiError = error as? APIError {
                    return apiError
                } else {
                    return APIError.networkError(error.localizedDescription)
                }
            }
            .eraseToAnyPublisher()
    }
    // ai.card直接リクエスト（メイン）
    private func request<T: Decodable>(_ endpoint: String,
                                      method: String = "GET",
                                      body: Data? = nil,
                                      authenticated: Bool = true) -> AnyPublisher<T, APIError> {
        guard let url = URL(string: "\(baseURL)\(endpoint)") else {
            return Fail(error: APIError.invalidURL).eraseToAnyPublisher()
        }
        var request = URLRequest(url: url)
        request.httpMethod = method
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        if authenticated, let token = authToken {
            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }
        if let body = body {
            request.httpBody = body
        }
        return URLSession.shared.dataTaskPublisher(for: request)
            .tryMap { data, response in
                guard let httpResponse = response as? HTTPURLResponse else {
                    throw APIError.networkError("Invalid response")
                }
                if httpResponse.statusCode == 401 {
                    throw APIError.unauthorized
                }
                if !(200...299).contains(httpResponse.statusCode) {
                    throw APIError.networkError("Status code: \(httpResponse.statusCode)")
                }
                return data
            }
            .decode(type: T.self, decoder: JSONDecoder())
            .mapError { error in
                if error is DecodingError {
                    return APIError.decodingError
                } else if let apiError = error as? APIError {
                    return apiError
                } else {
                    return APIError.networkError(error.localizedDescription)
                }
            }
            .eraseToAnyPublisher()
    }
    // MARK: - Auth
    func login(identifier: String, password: String) -> AnyPublisher<LoginResponse, APIError> {
        let loginRequest = LoginRequest(identifier: identifier, password: password)
        guard let body = try? JSONEncoder().encode(loginRequest) else {
            return Fail(error: APIError.decodingError).eraseToAnyPublisher()
        }
        return request("/auth/login", method: "POST", body: body, authenticated: false)
            .handleEvents(receiveOutput: { [weak self] (response: LoginResponse) in
                self?.authToken = response.accessToken
            })
            .eraseToAnyPublisher()
    }
    func logout() -> AnyPublisher<Void, APIError> {
        request("/auth/logout", method: "POST")
            .map { (_: [String: String]) in () }
            .handleEvents(receiveCompletion: { [weak self] _ in
                self?.authToken = nil
            })
            .eraseToAnyPublisher()
    }
    func verify() -> AnyPublisher<User, APIError> {
        request("/auth/verify")
    }
    // MARK: - Cards (ai.card直接アクセス)
    func drawCard(userDid: String, isPaid: Bool = false) -> AnyPublisher<CardDrawResult, APIError> {
        let body = try? JSONEncoder().encode([
            "user_did": userDid,
            "is_paid": isPaid
        ])
        return request("/cards/draw", method: "POST", body: body)
    }
    func getUserCards(userDid: String) -> AnyPublisher<[Card], APIError> {
        return request("/cards/user/\(userDid)")
    }
    func getCardDetails(cardId: Int) -> AnyPublisher<Card, APIError> {
        return request("/cards/\(cardId)")
    }
    func getGachaStats() -> AnyPublisher<GachaStats, APIError> {
        return request("/cards/stats")
    }
    func getUniqueCards() -> AnyPublisher<[[String: Any]], APIError> {
        return request("/cards/unique")
    }
    func getSystemStatus() -> AnyPublisher<[String: Any], APIError> {
        return request("/health")
    }
 }
 // MARK: - AI Enhanced API (Optional ai.gpt integration)
 extension APIClient {
    func analyzeCollection(userDid: String) -> AnyPublisher<CollectionAnalysis, APIError> {
        let parameters: [String: Any] = [
            "did": userDid
        ]
        return mcpRequest("/card_analyze_collection", parameters: parameters)
            .catch { error -> AnyPublisher<CollectionAnalysis, APIError> in
                // AI機能が利用できない場合のエラー
                return Fail(error: APIError.networkError("AI分析機能を利用するにはai.gptサーバーが必要です")).eraseToAnyPublisher()
            }
            .eraseToAnyPublisher()
    }
    func getEnhancedStats() -> AnyPublisher<GachaStats, APIError> {
        return mcpRequest("/card_get_gacha_stats", parameters: [:])
            .catch { [weak self] error -> AnyPublisher<GachaStats, APIError> in
                // AI機能が利用できない場合は基本統計にフォールバック
                print("AI統計が利用できません、基本統計に切り替えます: \(error)")
                return self?.getGachaStats() ?? Fail(error: error).eraseToAnyPublisher()
            }
            .eraseToAnyPublisher()
    }
    func isAIAvailable() -> AnyPublisher<Bool, Never> {
        guard let url = URL(string: "\(aiGptBaseURL)/health") else {
            return Just(false).eraseToAnyPublisher()
        }
        return URLSession.shared.dataTaskPublisher(for: url)
            .map { _ in true }
            .catch { _ in Just(false) }
            .eraseToAnyPublisher()
    }
 }
--- a/ios/AiCard/AiCard/Services/AtprotoOAuthService.swift
+++ b/ios/AiCard/AiCard/Services/AtprotoOAuthService.swift
@@ -0,0 +1,355 @@
 import Foundation
 import Combine
 import AuthenticationServices
 struct AtprotoSession: Codable {
    let did: String
    let handle: String
    let accessJwt: String
    let refreshJwt: String
    let email: String?
    let emailConfirmed: Bool?
 }
 class AtprotoOAuthService: NSObject, ObservableObject {
    static let shared = AtprotoOAuthService()
    @Published var session: AtprotoSession?
    @Published var isAuthenticated: Bool = false
    private var authSession: ASWebAuthenticationSession?
    private let clientId: String
    private let redirectUri: String
    private let scope = "atproto transition:generic"
    override init() {
        // Generate client metadata URL
        self.clientId = "\(Bundle.main.bundleIdentifier ?? "ai.card")/client-metadata.json"
        self.redirectUri = "aicard://oauth/callback"
        super.init()
        loadSessionFromKeychain()
    }
    // MARK: - OAuth Flow
    func initiateOAuthFlow() -> AnyPublisher<AtprotoSession, Error> {
        return Future { [weak self] promise in
            guard let self = self else {
                promise(.failure(OAuthError.invalidState))
                return
            }
            Task {
                do {
                    let authURL = try await self.buildAuthorizationURL()
                    DispatchQueue.main.async {
                        self.startWebAuthenticationSession(url: authURL) { result in
                            switch result {
                            case .success(let session):
                                self.session = session
                                self.isAuthenticated = true
                                self.saveSessionToKeychain(session)
                                promise(.success(session))
                            case .failure(let error):
                                promise(.failure(error))
                            }
                        }
                    }
                } catch {
                    promise(.failure(error))
                }
            }
        }
        .eraseToAnyPublisher()
    }
    private func buildAuthorizationURL() async throws -> URL {
        // Generate PKCE parameters
        let state = generateRandomString(32)
        let codeVerifier = generateRandomString(128)
        let codeChallenge = try generateCodeChallenge(from: codeVerifier)
        // Store PKCE parameters
        UserDefaults.standard.set(state, forKey: "oauth_state")
        UserDefaults.standard.set(codeVerifier, forKey: "oauth_code_verifier")
        // For development: use mock authorization server
        // In production, this would discover the actual atproto authorization server
        let authServer = "https://bsky.social" // Mock - should be discovered
        var components = URLComponents(string: "\(authServer)/oauth/authorize")!
        components.queryItems = [
            URLQueryItem(name: "response_type", value: "code"),
            URLQueryItem(name: "client_id", value: clientId),
            URLQueryItem(name: "redirect_uri", value: redirectUri),
            URLQueryItem(name: "scope", value: scope),
            URLQueryItem(name: "state", value: state),
            URLQueryItem(name: "code_challenge", value: codeChallenge),
            URLQueryItem(name: "code_challenge_method", value: "S256")
        ]
        guard let url = components.url else {
            throw OAuthError.invalidURL
        }
        return url
    }
    private func startWebAuthenticationSession(url: URL, completion: @escaping (Result<AtprotoSession, Error>) -> Void) {
        authSession = ASWebAuthenticationSession(url: url, callbackURLScheme: "aicard") { [weak self] callbackURL, error in
            if let error = error {
                if case ASWebAuthenticationSessionError.canceledLogin = error {
                    completion(.failure(OAuthError.userCancelled))
                } else {
                    completion(.failure(error))
                }
                return
            }
            guard let callbackURL = callbackURL else {
                completion(.failure(OAuthError.invalidCallback))
                return
            }
            Task {
                do {
                    let session = try await self?.handleOAuthCallback(callbackURL: callbackURL)
                    if let session = session {
                        completion(.success(session))
                    } else {
                        completion(.failure(OAuthError.invalidState))
                    }
                } catch {
                    completion(.failure(error))
                }
            }
        }
        authSession?.presentationContextProvider = self
        authSession?.prefersEphemeralWebBrowserSession = false
        authSession?.start()
    }
    private func handleOAuthCallback(callbackURL: URL) async throws -> AtprotoSession {
        guard let components = URLComponents(url: callbackURL, resolvingAgainstBaseURL: false),
              let queryItems = components.queryItems else {
            throw OAuthError.invalidCallback
        }
        var code: String?
        var state: String?
        var error: String?
        for item in queryItems {
            switch item.name {
            case "code":
                code = item.value
            case "state":
                state = item.value
            case "error":
                error = item.value
            default:
                break
            }
        }
        if let error = error {
            throw OAuthError.authorizationFailed(error)
        }
        guard let code = code, let state = state else {
            throw OAuthError.missingParameters
        }
        // Verify state
        let storedState = UserDefaults.standard.string(forKey: "oauth_state")
        guard state == storedState else {
            throw OAuthError.invalidState
        }
        // Get code verifier
        guard let codeVerifier = UserDefaults.standard.string(forKey: "oauth_code_verifier") else {
            throw OAuthError.missingCodeVerifier
        }
        // Exchange code for tokens
        let session = try await exchangeCodeForTokens(code: code, codeVerifier: codeVerifier)
        // Clean up temporary data
        UserDefaults.standard.removeObject(forKey: "oauth_state")
        UserDefaults.standard.removeObject(forKey: "oauth_code_verifier")
        return session
    }
    private func exchangeCodeForTokens(code: String, codeVerifier: String) async throws -> AtprotoSession {
        // This is a mock implementation
        // In production, this would make a proper token exchange request
        // For development, return a mock session
        let mockSession = AtprotoSession(
            did: "did:plc:mock123456789",
            handle: "user.bsky.social",
            accessJwt: "mock_access_token",
            refreshJwt: "mock_refresh_token",
            email: nil,
            emailConfirmed: nil
        )
        return mockSession
    }
    // MARK: - Session Management
    func refreshTokens() async throws -> AtprotoSession {
        guard let currentSession = session else {
            throw OAuthError.noSession
        }
        // This would make a proper token refresh request
        // For now, return the existing session
        return currentSession
    }
    func logout() {
        session = nil
        isAuthenticated = false
        deleteSessionFromKeychain()
        // Cancel any ongoing auth session
        authSession?.cancel()
        authSession = nil
    }
    // MARK: - Keychain Storage
    private func saveSessionToKeychain(_ session: AtprotoSession) {
        guard let data = try? JSONEncoder().encode(session) else { return }
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: "atproto_session",
            kSecValueData as String: data
        ]
        // Delete existing item
        SecItemDelete(query as CFDictionary)
        // Add new item
        SecItemAdd(query as CFDictionary, nil)
    }
    private func loadSessionFromKeychain() {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: "atproto_session",
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        if status == errSecSuccess,
           let data = result as? Data,
           let session = try? JSONDecoder().decode(AtprotoSession.self, from: data) {
            self.session = session
            self.isAuthenticated = true
        }
    }
    private func deleteSessionFromKeychain() {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: "atproto_session"
        ]
        SecItemDelete(query as CFDictionary)
    }
    // MARK: - Utility Methods
    private func generateRandomString(_ length: Int) -> String {
        let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
        return String((0..<length).map { _ in chars.randomElement()! })
    }
    private func generateCodeChallenge(from verifier: String) throws -> String {
        guard let data = verifier.data(using: .utf8) else {
            throw OAuthError.encodingError
        }
        let digest = SHA256.hash(data: data)
        return Data(digest).base64URLEncodedString()
    }
 }
 // MARK: - ASWebAuthenticationPresentationContextProviding
 extension AtprotoOAuthService: ASWebAuthenticationPresentationContextProviding {
    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
        return UIApplication.shared.windows.first { $0.isKeyWindow } ?? ASPresentationAnchor()
    }
 }
 // MARK: - Errors
 enum OAuthError: LocalizedError {
    case invalidURL
    case invalidState
    case invalidCallback
    case missingParameters
    case missingCodeVerifier
    case authorizationFailed(String)
    case userCancelled
    case noSession
    case encodingError
    var errorDescription: String? {
        switch self {
        case .invalidURL:
            return "無効なURLです"
        case .invalidState:
            return "無効な状態パラメータです"
        case .invalidCallback:
            return "無効なコールバックです"
        case .missingParameters:
            return "必要なパラメータが不足しています"
        case .missingCodeVerifier:
            return "コード検証子が見つかりません"
        case .authorizationFailed(let error):
            return "認証に失敗しました: \(error)"
        case .userCancelled:
            return "ユーザーによってキャンセルされました"
        case .noSession:
            return "セッションがありません"
        case .encodingError:
            return "エンコードエラーです"
        }
    }
 }
 // MARK: - Data Extension for Base64URL
 extension Data {
    func base64URLEncodedString() -> String {
        return base64EncodedString()
            .replacingOccurrences(of: "+", with: "-")
            .replacingOccurrences(of: "/", with: "_")
            .replacingOccurrences(of: "=", with: "")
    }
 }
 // MARK: - SHA256 (simplified for demo)
 import CryptoKit
 extension SHA256 {
    static func hash(data: Data) -> SHA256.Digest {
        return SHA256.hash(data: data)
    }
 }
--- a/ios/AiCard/AiCard/Services/AuthManager.swift
+++ b/ios/AiCard/AiCard/Services/AuthManager.swift
@@ -0,0 +1,138 @@
 import Foundation
 import Combine
 import SwiftUI
 class AuthManager: ObservableObject {
    @Published var isAuthenticated = false
    @Published var currentUser: User?
    @Published var isLoading = false
    @Published var errorMessage: String?
    @Published var authMode: AuthMode = .oauth
    private var cancellables = Set<AnyCancellable>()
    private let apiClient = APIClient.shared
    private let oauthService = AtprotoOAuthService.shared
    enum AuthMode {
        case oauth
        case legacy
    }
    init() {
        // Monitor OAuth service
        oauthService.$isAuthenticated
            .receive(on: DispatchQueue.main)
            .sink { [weak self] isAuth in
                if isAuth, let session = self?.oauthService.session {
                    self?.isAuthenticated = true
                    self?.currentUser = User(did: session.did, handle: session.handle)
                }
            }
            .store(in: &cancellables)
        checkAuthStatus()
    }
    private func checkAuthStatus() {
        isLoading = true
        // Check OAuth session first
        if oauthService.isAuthenticated, let session = oauthService.session {
            isAuthenticated = true
            currentUser = User(did: session.did, handle: session.handle)
            isLoading = false
            return
        }
        // Fallback to legacy auth
        apiClient.verify()
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure = completion {
                        self?.isAuthenticated = false
                        self?.currentUser = nil
                    }
                },
                receiveValue: { [weak self] user in
                    self?.isAuthenticated = true
                    self?.currentUser = user
                }
            )
            .store(in: &cancellables)
    }
    func loginWithOAuth() {
        isLoading = true
        errorMessage = nil
        oauthService.initiateOAuthFlow()
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.errorMessage = error.localizedDescription
                    }
                },
                receiveValue: { [weak self] session in
                    self?.isAuthenticated = true
                    self?.currentUser = User(did: session.did, handle: session.handle)
                }
            )
            .store(in: &cancellables)
    }
    func loginWithPassword(identifier: String, password: String) {
        isLoading = true
        errorMessage = nil
        apiClient.login(identifier: identifier, password: password)
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.errorMessage = self?.getErrorMessage(from: error)
                    }
                },
                receiveValue: { [weak self] response in
                    self?.isAuthenticated = true
                    self?.currentUser = User(did: response.did, handle: response.handle)
                }
            )
            .store(in: &cancellables)
    }
    func logout() {
        isLoading = true
        // Logout from both services
        oauthService.logout()
        apiClient.logout()
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] _ in
                    self?.isLoading = false
                    self?.isAuthenticated = false
                    self?.currentUser = nil
                    UserDefaults.standard.removeObject(forKey: "authToken")
                },
                receiveValue: { _ in }
            )
            .store(in: &cancellables)
    }
    private func getErrorMessage(from error: APIError) -> String {
        switch error {
        case .unauthorized:
            return "認証情報が正しくありません"
        case .networkError:
            return "ネットワークエラーが発生しました"
        default:
            return "エラーが発生しました"
        }
    }
 }
--- a/ios/AiCard/AiCard/Services/CardManager.swift
+++ b/ios/AiCard/AiCard/Services/CardManager.swift
@@ -0,0 +1,73 @@
 import Foundation
 import Combine
 import SwiftUI
 class CardManager: ObservableObject {
    @Published var userCards: [Card] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    @Published var currentDraw: CardDrawResult?
    @Published var isDrawing = false
    private var cancellables = Set<AnyCancellable>()
    private let apiClient = APIClient.shared
    func loadUserCards(userDid: String) {
        isLoading = true
        apiClient.getUserCards(userDid: userDid)
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.errorMessage = self?.getErrorMessage(from: error)
                    }
                },
                receiveValue: { [weak self] cards in
                    self?.userCards = cards
                }
            )
            .store(in: &cancellables)
    }
    func drawCard(userDid: String, isPaid: Bool = false) {
        isDrawing = true
        errorMessage = nil
        apiClient.drawCard(userDid: userDid, isPaid: isPaid)
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    if case .failure(let error) = completion {
                        self?.isDrawing = false
                        self?.errorMessage = self?.getErrorMessage(from: error)
                    }
                },
                receiveValue: { [weak self] result in
                    self?.currentDraw = result
                    // アニメーション終了後にカードを追加
                }
            )
            .store(in: &cancellables)
    }
    func completeCardDraw() {
        if let newCard = currentDraw?.card {
            userCards.append(newCard)
        }
        currentDraw = nil
        isDrawing = false
    }
    private func getErrorMessage(from error: APIError) -> String {
        switch error {
        case .unauthorized:
            return "認証が必要です"
        case .networkError:
            return "ネットワークエラーが発生しました"
        default:
            return "エラーが発生しました"
        }
    }
 }
--- a/ios/AiCard/AiCard/Utils/Color+Extensions.swift
+++ b/ios/AiCard/AiCard/Utils/Color+Extensions.swift
@@ -0,0 +1,28 @@
 import SwiftUI
 extension Color {
    init(hex: String) {
        let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int: UInt64 = 0
        Scanner(string: hex).scanHexInt64(&int)
        let a, r, g, b: UInt64
        switch hex.count {
        case 3: // RGB (12-bit)
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8: // ARGB (32-bit)
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            (a, r, g, b) = (1, 1, 1, 0)
        }
        self.init(
            .sRGB,
            red: Double(r) / 255,
            green: Double(g) / 255,
            blue:  Double(b) / 255,
            opacity: Double(a) / 255
        )
    }
 }
--- a/ios/AiCard/AiCard/Views/CardView.swift
+++ b/ios/AiCard/AiCard/Views/CardView.swift
@@ -0,0 +1,247 @@
 import SwiftUI
 struct CardView: View {
    let card: Card
    let isRevealing: Bool
    @State private var isFlipped = false
    init(card: Card, isRevealing: Bool = false) {
        self.card = card
        self.isRevealing = isRevealing
    }
    var body: some View {
        ZStack {
            // Card background
            RoundedRectangle(cornerRadius: 16)
                .fill(
                    LinearGradient(
                        gradient: Gradient(colors: gradientColors),
                        startPoint: .topLeading,
                        endPoint: .bottomTrailing
                    )
                )
                .frame(width: 200, height: 280)
            // Card content
            VStack(spacing: 16) {
                // Header
                HStack {
                    Text("#\(card.id)")
                        .font(.caption)
                        .foregroundColor(.white.opacity(0.7))
                    Spacer()
                    Text("CP: \(card.cp)")
                        .font(.caption)
                        .foregroundColor(.white.opacity(0.7))
                }
                Spacer()
                // Card name and icon
                VStack(spacing: 12) {
                    // Card icon (could be an image)
                    Circle()
                        .fill(Color(hex: cardInfo.color))
                        .frame(width: 60, height: 60)
                        .overlay(
                            Text(cardInfo.name.prefix(1))
                                .font(.title)
                                .fontWeight(.bold)
                                .foregroundColor(.white)
                        )
                    Text(cardInfo.name)
                        .font(.title2)
                        .fontWeight(.bold)
                        .foregroundColor(.white)
                        .multilineTextAlignment(.center)
                    if card.isUnique {
                        UniqueBadge()
                    }
                }
                Spacer()
                // Skill
                if let skill = card.skill, !skill.isEmpty {
                    Text(skill)
                        .font(.caption)
                        .foregroundColor(.white.opacity(0.8))
                        .padding(.horizontal, 8)
                        .padding(.vertical, 4)
                        .background(Color.black.opacity(0.3))
                        .cornerRadius(8)
                }
                // Rarity
                Text(card.status.displayName)
                    .font(.caption)
                    .foregroundColor(.white.opacity(0.7))
                    .textCase(.uppercase)
                    .tracking(1)
            }
            .padding(20)
            // Special effects
            if card.status == .kira {
                KiraEffect()
            } else if card.status == .unique {
                UniqueEffect()
            }
        }
        .rotation3DEffect(
            .degrees(isRevealing && !isFlipped ? 180 : 0),
            axis: (x: 0, y: 1, z: 0)
        )
        .onAppear {
            if isRevealing {
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                    withAnimation(.easeInOut(duration: 0.8)) {
                        isFlipped = true
                    }
                }
            }
        }
        .scaleEffect(isRevealing ? 1.1 : 1.0)
        .shadow(color: .black.opacity(0.3), radius: 10, x: 0, y: 5)
    }
    private var cardInfo: CardInfo {
        CardInfo.all[card.id] ?? CardInfo(id: card.id, name: "Unknown", color: "666666", description: "")
    }
    private var gradientColors: [Color] {
        card.status.gradientColors.map { Color(hex: $0) }
    }
 }
 struct UniqueBadge: View {
    @State private var phase: CGFloat = 0
    var body: some View {
        Text("UNIQUE")
            .font(.caption2)
            .fontWeight(.bold)
            .foregroundColor(.white)
            .padding(.horizontal, 12)
            .padding(.vertical, 4)
            .background(
                LinearGradient(
                    gradient: Gradient(colors: [
                        Color(hex: "ff00ff"),
                        Color(hex: "00ffff")
                    ]),
                    startPoint: .leading,
                    endPoint: .trailing
                )
                .hueRotation(.degrees(phase))
            )
            .cornerRadius(12)
            .onAppear {
                withAnimation(.linear(duration: 2).repeatForever(autoreverses: false)) {
                    phase = 360
                }
            }
    }
 }
 struct KiraEffect: View {
    @State private var sparkles: [SparkleData] = []
    var body: some View {
        ZStack {
            ForEach(sparkles, id: \.id) { sparkle in
                Image(systemName: "sparkle")
                    .foregroundColor(.yellow)
                    .font(.system(size: sparkle.size))
                    .position(x: sparkle.x, y: sparkle.y)
                    .opacity(sparkle.opacity)
            }
        }
        .onAppear {
            generateSparkles()
        }
    }
    private func generateSparkles() {
        for i in 0..<10 {
            let sparkle = SparkleData(
                id: i,
                x: CGFloat.random(in: 20...180),
                y: CGFloat.random(in: 20...260),
                size: CGFloat.random(in: 8...16),
                opacity: Double.random(in: 0.3...0.8)
            )
            sparkles.append(sparkle)
            DispatchQueue.main.asyncAfter(deadline: .now() + Double.random(in: 0...2)) {
                withAnimation(.easeInOut(duration: 1).repeatForever(autoreverses: true)) {
                    if let index = sparkles.firstIndex(where: { $0.id == sparkle.id }) {
                        sparkles[index].opacity = sparkles[index].opacity > 0.5 ? 0.2 : 0.8
                    }
                }
            }
        }
    }
 }
 struct UniqueEffect: View {
    @State private var pulseScale: CGFloat = 1.0
    var body: some View {
        RoundedRectangle(cornerRadius: 16)
            .stroke(
                LinearGradient(
                    gradient: Gradient(colors: [
                        Color(hex: "ff00ff"),
                        Color(hex: "00ffff"),
                        Color(hex: "ff00ff")
                    ]),
                    startPoint: .topLeading,
                    endPoint: .bottomTrailing
                ),
                lineWidth: 3
            )
            .scaleEffect(pulseScale)
            .opacity(0.8)
            .onAppear {
                withAnimation(.easeInOut(duration: 1.5).repeatForever(autoreverses: true)) {
                    pulseScale = 1.05
                }
            }
    }
 }
 struct SparkleData {
    let id: Int
    let x: CGFloat
    let y: CGFloat
    let size: CGFloat
    var opacity: Double
 }
 struct CardView_Previews: PreviewProvider {
    static var previews: some View {
        let sampleCard = Card(
            id: 0,
            cp: 100,
            status: .unique,
            skill: "サンプルスキル",
            ownerDid: "did:plc:example",
            obtainedAt: Date(),
            isUnique: true,
            uniqueId: "unique-123"
        )
        VStack {
            CardView(card: sampleCard)
            CardView(card: sampleCard, isRevealing: true)
        }
        .padding()
        .background(Color.black)
    }
 }
--- a/ios/AiCard/AiCard/Views/CollectionView.swift
+++ b/ios/AiCard/AiCard/Views/CollectionView.swift
@@ -0,0 +1,341 @@
 import SwiftUI
 struct CollectionView: View {
    @EnvironmentObject var authManager: AuthManager
    @EnvironmentObject var cardManager: CardManager
    @State private var selectedCard: Card?
    @State private var searchText = ""
    @State private var selectedRarity: CardRarity?
    @State private var showingFilters = false
    var filteredCards: [Card] {
        var cards = cardManager.userCards
        // Search filter
        if !searchText.isEmpty {
            cards = cards.filter { card in
                let cardInfo = CardInfo.all[card.id]
                return cardInfo?.name.localizedCaseInsensitiveContains(searchText) ?? false
            }
        }
        // Rarity filter
        if let selectedRarity = selectedRarity {
            cards = cards.filter { $0.status == selectedRarity }
        }
        return cards.sorted { $0.obtainedAt > $1.obtainedAt }
    }
    var body: some View {
        NavigationView {
            ZStack {
                // Background
                LinearGradient(
                    gradient: Gradient(colors: [
                        Color(hex: "0a0a0a"),
                        Color(hex: "1a1a1a")
                    ]),
                    startPoint: .top,
                    endPoint: .bottom
                )
                .ignoresSafeArea()
                VStack(spacing: 0) {
                    // Search and filter bar
                    VStack(spacing: 12) {
                        HStack {
                            // Search field
                            HStack {
                                Image(systemName: "magnifyingglass")
                                    .foregroundColor(.secondary)
                                TextField("カードを検索...", text: $searchText)
                                    .textFieldStyle(PlainTextFieldStyle())
                                if !searchText.isEmpty {
                                    Button(action: {
                                        searchText = ""
                                    }) {
                                        Image(systemName: "xmark.circle.fill")
                                            .foregroundColor(.secondary)
                                    }
                                }
                            }
                            .padding(12)
                            .background(Color.white.opacity(0.1))
                            .cornerRadius(12)
                            // Filter button
                            Button(action: {
                                showingFilters.toggle()
                            }) {
                                Image(systemName: "line.3.horizontal.decrease.circle")
                                    .font(.title2)
                                    .foregroundColor(Color(hex: "fff700"))
                            }
                        }
                        // Filter chips
                        if showingFilters {
                            ScrollView(.horizontal, showsIndicators: false) {
                                HStack(spacing: 8) {
                                    FilterChip(
                                        title: "すべて",
                                        isSelected: selectedRarity == nil
                                    ) {
                                        selectedRarity = nil
                                    }
                                    ForEach(CardRarity.allCases, id: \.self) { rarity in
                                        FilterChip(
                                            title: rarity.displayName,
                                            isSelected: selectedRarity == rarity
                                        ) {
                                            selectedRarity = selectedRarity == rarity ? nil : rarity
                                        }
                                    }
                                }
                                .padding(.horizontal)
                            }
                        }
                    }
                    .padding(.horizontal)
                    .padding(.top)
                    // Collection stats
                    CollectionStatsView(cards: cardManager.userCards)
                        .padding(.horizontal)
                        .padding(.vertical, 8)
                    // Card grid
                    if cardManager.isLoading {
                        Spacer()
                        ProgressView()
                            .progressViewStyle(CircularProgressViewStyle(tint: Color(hex: "fff700")))
                        Spacer()
                    } else if filteredCards.isEmpty {
                        Spacer()
                        EmptyCollectionView(hasCards: !cardManager.userCards.isEmpty)
                        Spacer()
                    } else {
                        ScrollView {
                            LazyVGrid(
                                columns: [
                                    GridItem(.flexible(), spacing: 16),
                                    GridItem(.flexible(), spacing: 16)
                                ],
                                spacing: 20
                            ) {
                                ForEach(filteredCards) { card in
                                    CardView(card: card)
                                        .scaleEffect(0.8)
                                        .onTapGesture {
                                            selectedCard = card
                                        }
                                }
                            }
                            .padding(.horizontal)
                            .padding(.bottom, 100)
                        }
                    }
                }
            }
            .navigationTitle("コレクション")
            .navigationBarTitleDisplayMode(.large)
            .onAppear {
                if let userDid = authManager.currentUser?.did {
                    cardManager.loadUserCards(userDid: userDid)
                }
            }
            .sheet(item: $selectedCard) { card in
                CardDetailView(card: card)
            }
        }
    }
 }
 struct FilterChip: View {
    let title: String
    let isSelected: Bool
    let action: () -> Void
    var body: some View {
        Button(action: action) {
            Text(title)
                .font(.caption)
                .fontWeight(isSelected ? .bold : .medium)
                .foregroundColor(isSelected ? .black : .white)
                .padding(.horizontal, 12)
                .padding(.vertical, 6)
                .background(
                    isSelected
                    ? Color(hex: "fff700")
                    : Color.white.opacity(0.1)
                )
                .cornerRadius(16)
        }
    }
 }
 struct CollectionStatsView: View {
    let cards: [Card]
    private var stats: (total: Int, unique: Int, completion: Double) {
        let total = cards.count
        let uniqueCards = Set(cards.map { $0.id }).count
        let completion = Double(uniqueCards) / 16.0 * 100
        return (total, uniqueCards, completion)
    }
    var body: some View {
        HStack(spacing: 20) {
            StatItem(title: "総枚数", value: "\(stats.total)")
            StatItem(title: "種類", value: "\(stats.unique)/16")
            StatItem(title: "完成度", value: String(format: "%.1f%%", stats.completion))
        }
        .padding(.vertical, 12)
        .padding(.horizontal, 16)
        .background(Color.white.opacity(0.05))
        .cornerRadius(12)
    }
 }
 struct StatItem: View {
    let title: String
    let value: String
    var body: some View {
        VStack(spacing: 4) {
            Text(value)
                .font(.headline)
                .fontWeight(.bold)
                .foregroundColor(Color(hex: "fff700"))
            Text(title)
                .font(.caption)
                .foregroundColor(.secondary)
        }
    }
 }
 struct EmptyCollectionView: View {
    let hasCards: Bool
    var body: some View {
        VStack(spacing: 16) {
            Image(systemName: hasCards ? "magnifyingglass" : "square.stack.3d.up")
                .font(.system(size: 48))
                .foregroundColor(.secondary)
            Text(hasCards ? "検索結果がありません" : "カードがありません")
                .font(.title2)
                .fontWeight(.semibold)
                .foregroundColor(.white)
            Text(hasCards ? "検索条件を変更してください" : "ガチャでカードを引いてみましょう")
                .font(.subheadline)
                .foregroundColor(.secondary)
                .multilineTextAlignment(.center)
        }
        .padding()
    }
 }
 struct CardDetailView: View {
    let card: Card
    @Environment(\.presentationMode) var presentationMode
    private var cardInfo: CardInfo {
        CardInfo.all[card.id] ?? CardInfo(id: card.id, name: "Unknown", color: "666666", description: "")
    }
    var body: some View {
        NavigationView {
            ZStack {
                LinearGradient(
                    gradient: Gradient(colors: [
                        Color(hex: "0a0a0a"),
                        Color(hex: "1a1a1a")
                    ]),
                    startPoint: .top,
                    endPoint: .bottom
                )
                .ignoresSafeArea()
                ScrollView {
                    VStack(spacing: 24) {
                        // Card display
                        CardView(card: card)
                            .scaleEffect(1.2)
                            .padding(.top, 20)
                        // Card details
                        VStack(alignment: .leading, spacing: 16) {
                            DetailRow(title: "ID", value: "#\(card.id)")
                            DetailRow(title: "名前", value: cardInfo.name)
                            DetailRow(title: "CP", value: "\(card.cp)")
                            DetailRow(title: "レアリティ", value: card.status.displayName)
                            if let skill = card.skill, !skill.isEmpty {
                                DetailRow(title: "スキル", value: skill)
                            }
                            if card.isUnique, let uniqueId = card.uniqueId {
                                DetailRow(title: "ユニークID", value: uniqueId)
                            }
                            DetailRow(
                                title: "取得日時",
                                value: DateFormatter.localizedString(
                                    from: card.obtainedAt,
                                    dateStyle: .medium,
                                    timeStyle: .short
                                )
                            )
                        }
                        .padding(.horizontal)
                    }
                    .padding(.bottom, 100)
                }
            }
            .navigationTitle(cardInfo.name)
            .navigationBarTitleDisplayMode(.inline)
            .navigationBarItems(
                trailing: Button("閉じる") {
                    presentationMode.wrappedValue.dismiss()
                }
            )
        }
    }
 }
 struct DetailRow: View {
    let title: String
    let value: String
    var body: some View {
        HStack {
            Text(title)
                .font(.subheadline)
                .foregroundColor(.secondary)
            Spacer()
            Text(value)
                .font(.subheadline)
                .fontWeight(.medium)
                .foregroundColor(.white)
        }
        .padding(.vertical, 4)
    }
 }
 struct CollectionView_Previews: PreviewProvider {
    static var previews: some View {
        CollectionView()
            .environmentObject(AuthManager())
            .environmentObject(CardManager())
    }
 }
--- a/ios/AiCard/AiCard/Views/GachaAnimationView.swift
+++ b/ios/AiCard/AiCard/Views/GachaAnimationView.swift
@@ -0,0 +1,310 @@
 import SwiftUI
 struct GachaAnimationView: View {
    let drawResult: CardDrawResult
    let onComplete: () -> Void
    @State private var phase: AnimationPhase = .opening
    @State private var packScale: CGFloat = 0
    @State private var packOpacity: Double = 0
    @State private var cardScale: CGFloat = 0
    @State private var cardOpacity: Double = 0
    @State private var showCard = false
    @State private var effectOpacity: Double = 0
    enum AnimationPhase {
        case opening
        case revealing
        case complete
    }
    var body: some View {
        ZStack {
            // Dark overlay
            Rectangle()
                .fill(Color.black.opacity(0.9))
                .ignoresSafeArea()
                .onTapGesture {
                    if phase == .complete {
                        onComplete()
                    }
                }
            // Background effects based on card rarity
            if phase != .opening {
                backgroundEffect
                    .opacity(effectOpacity)
            }
            // Pack animation
            if phase == .opening {
                GachaPackView()
                    .scaleEffect(packScale)
                    .opacity(packOpacity)
            }
            // Card reveal
            if showCard {
                CardView(card: drawResult.card, isRevealing: true)
                    .scaleEffect(cardScale)
                    .opacity(cardOpacity)
            }
            // Complete state overlay
            if phase == .complete {
                VStack {
                    Spacer()
                    VStack(spacing: 16) {
                        if drawResult.isNew {
                            Text("新しいカードを獲得！")
                                .font(.title2)
                                .fontWeight(.bold)
                                .foregroundColor(Color(hex: "fff700"))
                        }
                        Text("タップして続ける")
                            .font(.caption)
                            .foregroundColor(.white.opacity(0.7))
                    }
                    .padding(.bottom, 50)
                }
            }
        }
        .onAppear {
            startAnimation()
        }
    }
    private var backgroundEffect: some View {
        Group {
            switch drawResult.animationType {
            case "unique":
                UniqueBackgroundEffect()
            case "kira":
                KiraBackgroundEffect()
            case "rare":
                RareBackgroundEffect()
            default:
                EmptyView()
            }
        }
    }
    private func startAnimation() {
        // Phase 1: Pack appears
        withAnimation(.spring(response: 0.6, dampingFraction: 0.8)) {
            packScale = 1.0
            packOpacity = 1.0
        }
        // Phase 2: Pack disappears, card appears
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
            withAnimation(.easeOut(duration: 0.3)) {
                packOpacity = 0
            }
            phase = .revealing
            showCard = true
            withAnimation(.spring(response: 0.8, dampingFraction: 0.6)) {
                cardScale = 1.0
                cardOpacity = 1.0
                effectOpacity = 1.0
            }
        }
        // Phase 3: Animation complete
        DispatchQueue.main.asyncAfter(deadline: .now() + 3.5) {
            phase = .complete
        }
    }
 }
 struct GachaPackView: View {
    @State private var glowIntensity: Double = 0.5
    var body: some View {
        ZStack {
            // Pack background
            RoundedRectangle(cornerRadius: 20)
                .fill(
                    LinearGradient(
                        gradient: Gradient(colors: [
                            Color(hex: "667eea"),
                            Color(hex: "764ba2")
                        ]),
                        startPoint: .topLeading,
                        endPoint: .bottomTrailing
                    )
                )
                .frame(width: 150, height: 200)
            // Pack glow
            RoundedRectangle(cornerRadius: 20)
                .stroke(Color.white, lineWidth: 2)
                .frame(width: 150, height: 200)
                .blur(radius: 10)
                .opacity(glowIntensity)
            // Pack label
            VStack {
                Image(systemName: "sparkles")
                    .font(.title)
                    .foregroundColor(.white)
                Text("ai.card")
                    .font(.headline)
                    .fontWeight(.bold)
                    .foregroundColor(.white)
            }
        }
        .onAppear {
            withAnimation(.easeInOut(duration: 1).repeatForever(autoreverses: true)) {
                glowIntensity = 1.0
            }
        }
    }
 }
 struct UniqueBackgroundEffect: View {
    @State private var particles: [ParticleData] = []
    @State private var burstScale: CGFloat = 0
    var body: some View {
        ZStack {
            // Radial burst
            Circle()
                .fill(
                    RadialGradient(
                        gradient: Gradient(colors: [
                            Color(hex: "ff00ff").opacity(0.8),
                            Color.clear
                        ]),
                        center: .center,
                        startRadius: 0,
                        endRadius: 200
                    )
                )
                .scaleEffect(burstScale)
                .onAppear {
                    withAnimation(.easeOut(duration: 1)) {
                        burstScale = 3
                    }
                }
            // Floating particles
            ForEach(particles, id: \.id) { particle in
                Circle()
                    .fill(Color(hex: particle.color))
                    .frame(width: particle.size, height: particle.size)
                    .position(x: particle.x, y: particle.y)
                    .opacity(particle.opacity)
            }
        }
        .onAppear {
            generateParticles()
        }
    }
    private func generateParticles() {
        for i in 0..<20 {
            let particle = ParticleData(
                id: i,
                x: CGFloat.random(in: 0...UIScreen.main.bounds.width),
                y: CGFloat.random(in: 0...UIScreen.main.bounds.height),
                size: CGFloat.random(in: 4...12),
                color: ["ff00ff", "00ffff", "ffffff"].randomElement() ?? "ffffff",
                opacity: Double.random(in: 0.3...0.8)
            )
            particles.append(particle)
        }
    }
 }
 struct KiraBackgroundEffect: View {
    @State private var sparkleOffset: CGFloat = -100
    var body: some View {
        ZStack {
            ForEach(0..<5, id: \.self) { i in
                Rectangle()
                    .fill(
                        LinearGradient(
                            gradient: Gradient(colors: [
                                Color.clear,
                                Color.yellow.opacity(0.3),
                                Color.clear
                            ]),
                            startPoint: .leading,
                            endPoint: .trailing
                        )
                    )
                    .frame(width: 2, height: UIScreen.main.bounds.height)
                    .rotationEffect(.degrees(45))
                    .offset(x: sparkleOffset + CGFloat(i * 50))
            }
        }
        .onAppear {
            withAnimation(.linear(duration: 2).repeatForever(autoreverses: false)) {
                sparkleOffset = UIScreen.main.bounds.width + 100
            }
        }
    }
 }
 struct RareBackgroundEffect: View {
    @State private var rippleScale: CGFloat = 0
    var body: some View {
        ZStack {
            ForEach(0..<3, id: \.self) { i in
                Circle()
                    .stroke(Color.blue.opacity(0.3), lineWidth: 2)
                    .scaleEffect(rippleScale)
                    .opacity(1 - rippleScale)
                    .animation(
                        .easeOut(duration: 2)
                        .delay(Double(i) * 0.3)
                        .repeatForever(autoreverses: false),
                        value: rippleScale
                    )
            }
        }
        .onAppear {
            rippleScale = 3
        }
    }
 }
 struct ParticleData {
    let id: Int
    let x: CGFloat
    let y: CGFloat
    let size: CGFloat
    let color: String
    let opacity: Double
 }
 struct GachaAnimationView_Previews: PreviewProvider {
    static var previews: some View {
        let sampleResult = CardDrawResult(
            card: Card(
                id: 0,
                cp: 500,
                status: .unique,
                skill: "サンプルスキル",
                ownerDid: "did:plc:example",
                obtainedAt: Date(),
                isUnique: true,
                uniqueId: "unique-123"
            ),
            isNew: true,
            animationType: "unique"
        )
        GachaAnimationView(drawResult: sampleResult) {
            print("Animation complete")
        }
    }
 }
--- a/ios/AiCard/AiCard/Views/GachaView.swift
+++ b/ios/AiCard/AiCard/Views/GachaView.swift
@@ -0,0 +1,190 @@
 import SwiftUI
 struct GachaView: View {
    @EnvironmentObject var authManager: AuthManager
    @EnvironmentObject var cardManager: CardManager
    @State private var showingAnimation = false
    var body: some View {
        ZStack {
            // Background
            LinearGradient(
                gradient: Gradient(colors: [
                    Color(hex: "0a0a0a"),
                    Color(hex: "1a1a1a")
                ]),
                startPoint: .top,
                endPoint: .bottom
            )
            .ignoresSafeArea()
            VStack(spacing: 40) {
                // Title
                VStack(spacing: 16) {
                    Text("カードを引く")
                        .font(.largeTitle)
                        .fontWeight(.bold)
                        .foregroundColor(.white)
                    if let user = authManager.currentUser {
                        Text("@\(user.handle)")
                            .font(.subheadline)
                            .foregroundColor(Color(hex: "fff700"))
                    }
                }
                Spacer()
                // Gacha buttons
                VStack(spacing: 20) {
                    GachaButton(
                        title: "通常ガチャ",
                        subtitle: "無料でカードを1枚引く",
                        colors: [Color(hex: "667eea"), Color(hex: "764ba2")],
                        action: {
                            drawCard(isPaid: false)
                        },
                        isLoading: cardManager.isDrawing
                    )
                    GachaButton(
                        title: "プレミアムガチャ",
                        subtitle: "レア確率アップ！",
                        colors: [Color(hex: "f093fb"), Color(hex: "f5576c")],
                        action: {
                            drawCard(isPaid: true)
                        },
                        isLoading: cardManager.isDrawing,
                        isPremium: true
                    )
                }
                .padding(.horizontal, 32)
                if let errorMessage = cardManager.errorMessage {
                    Text(errorMessage)
                        .font(.caption)
                        .foregroundColor(.red)
                        .padding()
                }
                Spacer()
            }
            .padding()
            // Gacha animation overlay
            if let currentDraw = cardManager.currentDraw {
                GachaAnimationView(
                    drawResult: currentDraw,
                    onComplete: {
                        cardManager.completeCardDraw()
                    }
                )
                .transition(.opacity)
                .zIndex(1000)
            }
        }
        .onAppear {
            if let userDid = authManager.currentUser?.did {
                cardManager.loadUserCards(userDid: userDid)
            }
        }
    }
    private func drawCard(isPaid: Bool) {
        guard let userDid = authManager.currentUser?.did else { return }
        cardManager.drawCard(userDid: userDid, isPaid: isPaid)
    }
 }
 struct GachaButton: View {
    let title: String
    let subtitle: String
    let colors: [Color]
    let action: () -> Void
    let isLoading: Bool
    let isPremium: Bool
    init(title: String, subtitle: String, colors: [Color], action: @escaping () -> Void, isLoading: Bool, isPremium: Bool = false) {
        self.title = title
        self.subtitle = subtitle
        self.colors = colors
        self.action = action
        self.isLoading = isLoading
        self.isPremium = isPremium
    }
    var body: some View {
        Button(action: action) {
            VStack(spacing: 8) {
                Text(title)
                    .font(.title2)
                    .fontWeight(.bold)
                    .foregroundColor(.white)
                Text(subtitle)
                    .font(.caption)
                    .foregroundColor(.white.opacity(0.8))
            }
            .frame(maxWidth: .infinity)
            .frame(height: 80)
            .background(
                ZStack {
                    LinearGradient(
                        gradient: Gradient(colors: colors),
                        startPoint: .leading,
                        endPoint: .trailing
                    )
                    if isPremium {
                        // Shimmer effect for premium
                        ShimmerView()
                    }
                }
            )
            .cornerRadius(16)
            .shadow(color: colors.first?.opacity(0.3) ?? .clear, radius: 10, x: 0, y: 5)
            .overlay(
                Group {
                    if isLoading {
                        ProgressView()
                            .progressViewStyle(CircularProgressViewStyle(tint: .white))
                    }
                }
            )
        }
        .disabled(isLoading)
        .scaleEffect(isLoading ? 0.95 : 1.0)
        .animation(.easeInOut(duration: 0.1), value: isLoading)
    }
 }
 struct ShimmerView: View {
    @State private var phase: CGFloat = 0
    var body: some View {
        LinearGradient(
            gradient: Gradient(colors: [
                .clear,
                .white.opacity(0.2),
                .clear
            ]),
            startPoint: .leading,
            endPoint: .trailing
        )
        .rotationEffect(.degrees(45))
        .offset(x: phase)
        .onAppear {
            withAnimation(.linear(duration: 2).repeatForever(autoreverses: false)) {
                phase = 300
            }
        }
    }
 }
 struct GachaView_Previews: PreviewProvider {
    static var previews: some View {
        GachaView()
            .environmentObject(AuthManager())
            .environmentObject(CardManager())
    }
 }
--- a/ios/AiCard/AiCard/Views/LoginView.swift
+++ b/ios/AiCard/AiCard/Views/LoginView.swift
@@ -0,0 +1,157 @@
 import SwiftUI
 struct LoginView: View {
    @EnvironmentObject var authManager: AuthManager
    @State private var identifier = ""
    @State private var password = ""
    @State private var showingPassword = false
    var body: some View {
        ZStack {
            // Background
            LinearGradient(
                gradient: Gradient(colors: [
                    Color(hex: "0a0a0a"),
                    Color(hex: "1a1a1a")
                ]),
                startPoint: .top,
                endPoint: .bottom
            )
            .ignoresSafeArea()
            VStack(spacing: 40) {
                // Logo and title
                VStack(spacing: 20) {
                    Text("ai.card")
                        .font(.system(size: 48, weight: .bold, design: .rounded))
                        .foregroundStyle(
                            LinearGradient(
                                gradient: Gradient(colors: [
                                    Color(hex: "fff700"),
                                    Color(hex: "ff00ff")
                                ]),
                                startPoint: .leading,
                                endPoint: .trailing
                            )
                        )
                    Text("atprotoベースカードゲーム")
                        .font(.title3)
                        .foregroundColor(.secondary)
                }
                // Login form
                VStack(spacing: 24) {
                    VStack(alignment: .leading, spacing: 8) {
                        Text("ハンドル または DID")
                            .font(.caption)
                            .foregroundColor(.secondary)
                        TextField("your.bsky.social", text: $identifier)
                            .textFieldStyle(CustomTextFieldStyle())
                            .autocapitalization(.none)
                            .disableAutocorrection(true)
                    }
                    VStack(alignment: .leading, spacing: 8) {
                        Text("アプリパスワード")
                            .font(.caption)
                            .foregroundColor(.secondary)
                        HStack {
                            if showingPassword {
                                TextField("アプリパスワード", text: $password)
                            } else {
                                SecureField("アプリパスワード", text: $password)
                            }
                            Button(action: {
                                showingPassword.toggle()
                            }) {
                                Image(systemName: showingPassword ? "eye.slash" : "eye")
                                    .foregroundColor(.secondary)
                            }
                        }
                        .textFieldStyle(CustomTextFieldStyle())
                        Text("メインパスワードではなく、アプリパスワードを使用してください")
                            .font(.caption2)
                            .foregroundColor(.secondary)
                    }
                    if let errorMessage = authManager.errorMessage {
                        Text(errorMessage)
                            .font(.caption)
                            .foregroundColor(.red)
                            .padding(.horizontal)
                    }
                    Button(action: {
                        authManager.login(identifier: identifier, password: password)
                    }) {
                        HStack {
                            if authManager.isLoading {
                                ProgressView()
                                    .progressViewStyle(CircularProgressViewStyle(tint: .black))
                                    .scaleEffect(0.8)
                            }
                            Text(authManager.isLoading ? "ログイン中..." : "ログイン")
                                .font(.headline)
                                .foregroundColor(.black)
                        }
                        .frame(maxWidth: .infinity)
                        .frame(height: 50)
                        .background(
                            LinearGradient(
                                gradient: Gradient(colors: [
                                    Color(hex: "fff700"),
                                    Color(hex: "ffd700")
                                ]),
                                startPoint: .leading,
                                endPoint: .trailing
                            )
                        )
                        .cornerRadius(12)
                    }
                    .disabled(authManager.isLoading || identifier.isEmpty || password.isEmpty)
                    .opacity(authManager.isLoading || identifier.isEmpty || password.isEmpty ? 0.6 : 1.0)
                }
                .padding(.horizontal, 32)
                Spacer()
                VStack(spacing: 12) {
                    Text("ai.cardはatprotoアカウントを使用します")
                        .font(.caption)
                        .foregroundColor(.secondary)
                    Text("データはあなたのPDSに保存されます")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }
            .padding()
        }
    }
 }
 struct CustomTextFieldStyle: TextFieldStyle {
    func _body(configuration: TextField<Self._Label>) -> some View {
        configuration
            .padding()
            .background(Color.white.opacity(0.1))
            .cornerRadius(12)
            .overlay(
                RoundedRectangle(cornerRadius: 12)
                    .stroke(Color.white.opacity(0.2), lineWidth: 1)
            )
    }
 }
 struct LoginView_Previews: PreviewProvider {
    static var previews: some View {
        LoginView()
            .environmentObject(AuthManager())
    }
 }
--- a/ios/AiCard/AiCard/Views/ProfileView.swift
+++ b/ios/AiCard/AiCard/Views/ProfileView.swift
@@ -0,0 +1,265 @@
 import SwiftUI
 struct ProfileView: View {
    @EnvironmentObject var authManager: AuthManager
    @EnvironmentObject var cardManager: CardManager
    @State private var showingLogoutAlert = false
    var body: some View {
        NavigationView {
            ZStack {
                // Background
                LinearGradient(
                    gradient: Gradient(colors: [
                        Color(hex: "0a0a0a"),
                        Color(hex: "1a1a1a")
                    ]),
                    startPoint: .top,
                    endPoint: .bottom
                )
                .ignoresSafeArea()
                ScrollView {
                    VStack(spacing: 24) {
                        // Profile header
                        if let user = authManager.currentUser {
                            ProfileHeaderView(user: user)
                        }
                        // Collection summary
                        CollectionSummaryView(cards: cardManager.userCards)
                        // Menu items
                        VStack(spacing: 1) {
                            MenuRow(
                                icon: "arrow.triangle.2.circlepath",
                                title: "データ同期",
                                subtitle: "atproto PDSと同期"
                            ) {
                                // TODO: Implement sync
                            }
                            MenuRow(
                                icon: "crown",
                                title: "ユニークカード",
                                subtitle: "所有しているユニークカード"
                            ) {
                                // TODO: Show unique cards
                            }
                            MenuRow(
                                icon: "info.circle",
                                title: "アプリについて",
                                subtitle: "バージョン情報"
                            ) {
                                // TODO: Show about
                            }
                        }
                        .background(Color.white.opacity(0.05))
                        .cornerRadius(12)
                        Spacer(minLength: 40)
                        // Logout button
                        Button(action: {
                            showingLogoutAlert = true
                        }) {
                            HStack {
                                Image(systemName: "rectangle.portrait.and.arrow.right")
                                Text("ログアウト")
                            }
                            .font(.headline)
                            .foregroundColor(.red)
                            .frame(maxWidth: .infinity)
                            .frame(height: 50)
                            .background(Color.red.opacity(0.1))
                            .cornerRadius(12)
                            .overlay(
                                RoundedRectangle(cornerRadius: 12)
                                    .stroke(Color.red.opacity(0.3), lineWidth: 1)
                            )
                        }
                        Spacer(minLength: 100)
                    }
                    .padding(.horizontal)
                }
            }
            .navigationTitle("プロフィール")
            .navigationBarTitleDisplayMode(.large)
            .alert("ログアウト", isPresented: $showingLogoutAlert) {
                Button("キャンセル", role: .cancel) { }
                Button("ログアウト", role: .destructive) {
                    authManager.logout()
                }
            } message: {
                Text("ログアウトしますか？")
            }
        }
    }
 }
 struct ProfileHeaderView: View {
    let user: User
    var body: some View {
        VStack(spacing: 16) {
            // Avatar
            Circle()
                .fill(
                    LinearGradient(
                        gradient: Gradient(colors: [
                            Color(hex: "fff700"),
                            Color(hex: "ff00ff")
                        ]),
                        startPoint: .topLeading,
                        endPoint: .bottomTrailing
                    )
                )
                .frame(width: 80, height: 80)
                .overlay(
                    Text(user.handle.prefix(1).uppercased())
                        .font(.title)
                        .fontWeight(.bold)
                        .foregroundColor(.black)
                )
            // User info
            VStack(spacing: 4) {
                Text("@\(user.handle)")
                    .font(.title2)
                    .fontWeight(.bold)
                    .foregroundColor(.white)
                Text(user.did)
                    .font(.caption)
                    .foregroundColor(.secondary)
                    .lineLimit(1)
                    .truncationMode(.middle)
            }
        }
        .padding(.vertical, 20)
    }
 }
 struct CollectionSummaryView: View {
    let cards: [Card]
    private var summary: (total: Int, unique: Int, rarest: CardRarity?) {
        let total = cards.count
        let uniqueCount = cards.filter { $0.isUnique }.count
        let rarest = cards.map { $0.status }.max { lhs, rhs in
            rarityOrder(lhs) < rarityOrder(rhs)
        }
        return (total, uniqueCount, rarest)
    }
    private func rarityOrder(_ rarity: CardRarity) -> Int {
        switch rarity {
        case .normal: return 0
        case .rare: return 1
        case .superRare: return 2
        case .kira: return 3
        case .unique: return 4
        }
    }
    var body: some View {
        VStack(spacing: 16) {
            Text("コレクション統計")
                .font(.headline)
                .foregroundColor(.white)
            HStack(spacing: 20) {
                SummaryItem(
                    title: "総カード数",
                    value: "\(summary.total)",
                    color: Color(hex: "fff700")
                )
                SummaryItem(
                    title: "ユニーク",
                    value: "\(summary.unique)",
                    color: Color(hex: "ff00ff")
                )
                if let rarest = summary.rarest {
                    SummaryItem(
                        title: "最高レア",
                        value: rarest.displayName,
                        color: Color(hex: rarest.gradientColors.first ?? "ffffff")
                    )
                }
            }
        }
        .padding()
        .background(Color.white.opacity(0.05))
        .cornerRadius(12)
    }
 }
 struct SummaryItem: View {
    let title: String
    let value: String
    let color: Color
    var body: some View {
        VStack(spacing: 8) {
            Text(value)
                .font(.title2)
                .fontWeight(.bold)
                .foregroundColor(color)
            Text(title)
                .font(.caption)
                .foregroundColor(.secondary)
                .multilineTextAlignment(.center)
        }
        .frame(maxWidth: .infinity)
    }
 }
 struct MenuRow: View {
    let icon: String
    let title: String
    let subtitle: String
    let action: () -> Void
    var body: some View {
        Button(action: action) {
            HStack(spacing: 12) {
                Image(systemName: icon)
                    .font(.title2)
                    .foregroundColor(Color(hex: "fff700"))
                    .frame(width: 24)
                VStack(alignment: .leading, spacing: 2) {
                    Text(title)
                        .font(.headline)
                        .foregroundColor(.white)
                    Text(subtitle)
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
                Spacer()
                Image(systemName: "chevron.right")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
            .padding()
        }
        .buttonStyle(PlainButtonStyle())
    }
 }
 struct ProfileView_Previews: PreviewProvider {
    static var previews: some View {
        ProfileView()
            .environmentObject(AuthManager())
            .environmentObject(CardManager())
    }
 }
--- a/ios/Package.swift
+++ b/ios/Package.swift
@@ -0,0 +1,28 @@
 // swift-tools-version: 5.7
 import PackageDescription
 let package = Package(
    name: "AiCard",
    platforms: [
        .iOS(.v16)
    ],
    products: [
        .library(
            name: "AiCard",
            targets: ["AiCard"]
        ),
    ],
    dependencies: [
        // SwiftUI is included by default
    ],
    targets: [
        .target(
            name: "AiCard",
            dependencies: []
        ),
        .testTarget(
            name: "AiCardTests",
            dependencies: ["AiCard"]
        ),
    ]
 )
--- a/ios/README.md
+++ b/ios/README.md
@@ -0,0 +1,121 @@
 # ai.card iOS App
 atprotoベースのカードゲーム「ai.card」のiOSアプリです。
 ## 特徴
 - **atproto統合**: 分散型認証とデータ主権
 - **リッチなアニメーション**: ガチャの迫力ある演出
 - **カードコレクション**: 美しいカード表示とフィルタリング
 - **ユニークカードシステム**: 世界で一人だけが所有できるカード
 ## アーキテクチャ
 ### MVVM + Combine
 ```
 Views/
 ├── LoginView          # atprotoログイン
 ├── GachaView          # ガチャ画面
 ├── CollectionView     # コレクション画面
 ├── ProfileView        # プロフィール画面
 ├── CardView           # カード表示コンポーネント
 └── GachaAnimationView # ガチャアニメーション
 Services/
 ├── APIClient          # REST API通信
 ├── AuthManager        # 認証管理
 └── CardManager        # カード管理
 Models/
 ├── Card               # カードデータモデル
 └── User               # ユーザーデータモデル
 ```
 ### 技術スタック
 - **UI**: SwiftUI
 - **データフロー**: Combine
 - **ネットワーク**: URLSession
 - **認証**: atproto (JWT)
 - **最小対応OS**: iOS 16.0
 ## セットアップ
 ### 1. Xcodeプロジェクトを開く
 ```bash
 cd ios/AiCard
 open AiCard.xcodeproj
 ```
 ### 2. API設定
 開発環境では自動的に `localhost:8000` に接続します。
 本番環境では `api.card.syui.ai` に接続します。
 ### 3. ビルド & 実行
 - シミュレーターまたは実機でビルド
 - atprotoアカウントでログイン
 - ガチャを引いてカードを集める
 ## 主要機能
 ### 認証
 - atproto DIDベース認証
 - アプリパスワード使用
 - 自動セッション管理
 ### ガチャシステム
 - 通常ガチャ（無料）
 - プレミアムガチャ（確率アップ）
 - レアリティ別アニメーション
 - ユニークカード対応
 ### カードコレクション
 - グリッド表示
 - 検索機能
 - レアリティフィルタ
 - 詳細表示
 ### プロフィール
 - ユーザー情報表示
 - コレクション統計
 - データ同期機能
 ## カードシステム
 ### レアリティ
 - **ノーマル**: 基本カード
 - **レア**: 少し珍しいカード
 - **スーパーレア**: とても珍しいカード
 - **キラ**: 光る演出付きカード（0.1%）
 - **ユニーク**: 世界で一人だけ（0.0001%）
 ### 視覚効果
 - レアリティ別グラデーション
 - キラカードのスパークル効果
 - ユニークカードのオーラ効果
 - 3Dフリップアニメーション
 ## 今後の実装予定
 - [ ] Push通知
 - [ ] カード交換機能
 - [ ] AI.verse連携
 - [ ] ダークモード対応
 - [ ] iPad最適化
 - [ ] ウィジェット対応
 ## 注意事項
 - iOS 16.0以上が必要
 - atprotoアカウントが必要
 - インターネット接続が必要
--- a/migrations/postgres/001_initial.sql
+++ b/migrations/postgres/001_initial.sql
@@ -0,0 +1,134 @@
 -- PostgreSQL migration for ai.card database schema
 -- Create custom types
 CREATE TYPE card_rarity AS ENUM ('normal', 'rare', 'super_rare', 'kira', 'unique');
 -- Enable UUID extension
 CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
 -- Users table - stores atproto DID-based user information
 CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    did TEXT NOT NULL UNIQUE,   -- atproto Decentralized Identifier
    handle TEXT NOT NULL,       -- atproto handle (e.g., alice.bsky.social)
    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
 );
 CREATE INDEX IF NOT EXISTS idx_users_did ON users(did);
 CREATE INDEX IF NOT EXISTS idx_users_handle ON users(handle);
 -- Card master data - template definitions for all card types
 CREATE TABLE IF NOT EXISTS card_master (
    id INTEGER PRIMARY KEY,     -- Card ID (0-15 in current system)
    name TEXT NOT NULL,         -- Card name (e.g., "ai", "dream", "radiance")
    base_cp_min INTEGER NOT NULL,  -- Minimum base CP for this card
    base_cp_max INTEGER NOT NULL,  -- Maximum base CP for this card
    color TEXT NOT NULL,        -- Card color theme
    description TEXT NOT NULL   -- Card description/lore
 );
 -- User cards - actual card instances owned by users
 CREATE TABLE IF NOT EXISTS user_cards (
    id SERIAL PRIMARY KEY,
    user_id INTEGER NOT NULL,
    card_id INTEGER NOT NULL,   -- References card_master.id
    cp INTEGER NOT NULL,        -- Calculated CP (base_cp * rarity_multiplier)
    status card_rarity NOT NULL, -- Card rarity
    skill TEXT,                 -- Optional skill description
    obtained_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
    is_unique BOOLEAN NOT NULL DEFAULT FALSE,
    unique_id UUID,             -- UUID for unique cards
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    FOREIGN KEY (card_id) REFERENCES card_master(id)
 );
 CREATE INDEX IF NOT EXISTS idx_user_cards_user_id ON user_cards(user_id);
 CREATE INDEX IF NOT EXISTS idx_user_cards_card_id ON user_cards(card_id);
 CREATE INDEX IF NOT EXISTS idx_user_cards_status ON user_cards(status);
 CREATE INDEX IF NOT EXISTS idx_user_cards_unique_id ON user_cards(unique_id);
 -- Global unique card registry - tracks ownership of unique cards
 CREATE TABLE IF NOT EXISTS unique_card_registry (
    id SERIAL PRIMARY KEY,
    unique_id UUID NOT NULL UNIQUE,    -- UUID from user_cards.unique_id
    card_id INTEGER NOT NULL,          -- Which card type is unique
    owner_did TEXT NOT NULL,           -- Current owner's atproto DID
    obtained_at TIMESTAMP WITH TIME ZONE NOT NULL,
    verse_skill_id TEXT,               -- Optional verse skill reference
    FOREIGN KEY (card_id) REFERENCES card_master(id),
    UNIQUE(card_id)  -- Only one unique per card_id allowed
 );
 CREATE INDEX IF NOT EXISTS idx_unique_registry_card_id ON unique_card_registry(card_id);
 CREATE INDEX IF NOT EXISTS idx_unique_registry_owner_did ON unique_card_registry(owner_did);
 -- Draw history - tracks all gacha draws for statistics
 CREATE TABLE IF NOT EXISTS draw_history (
    id SERIAL PRIMARY KEY,
    user_id INTEGER NOT NULL,
    card_id INTEGER NOT NULL,
    status card_rarity NOT NULL,
    cp INTEGER NOT NULL,
    is_paid BOOLEAN NOT NULL DEFAULT FALSE,  -- Paid vs free gacha
    drawn_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    FOREIGN KEY (card_id) REFERENCES card_master(id)
 );
 CREATE INDEX IF NOT EXISTS idx_draw_history_user_id ON draw_history(user_id);
 CREATE INDEX IF NOT EXISTS idx_draw_history_drawn_at ON draw_history(drawn_at);
 CREATE INDEX IF NOT EXISTS idx_draw_history_status ON draw_history(status);
 -- Gacha pools - special event pools with rate-ups
 CREATE TABLE IF NOT EXISTS gacha_pools (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    description TEXT NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    start_at TIMESTAMP WITH TIME ZONE,
    end_at TIMESTAMP WITH TIME ZONE,
    pickup_card_ids INTEGER[],          -- Array of card IDs
    rate_up_multiplier DECIMAL(4,2) NOT NULL DEFAULT 1.0
 );
 CREATE INDEX IF NOT EXISTS idx_gacha_pools_active ON gacha_pools(is_active);
 CREATE INDEX IF NOT EXISTS idx_gacha_pools_dates ON gacha_pools(start_at, end_at);
 -- Insert default card master data (0-15 cards from ai.json)
 INSERT INTO card_master (id, name, base_cp_min, base_cp_max, color, description) VALUES
    (0, 'ai', 100, 200, '#4A90E2', 'The core essence of existence'),
    (1, 'dream', 90, 180, '#9B59B6', 'Visions of possibility'),
    (2, 'radiance', 110, 220, '#F39C12', 'Brilliant light energy'),
    (3, 'neutron', 120, 240, '#34495E', 'Dense stellar core'),
    (4, 'sun', 130, 260, '#E74C3C', 'Solar radiance'),
    (5, 'night', 80, 160, '#2C3E50', 'Darkness and mystery'),
    (6, 'snow', 70, 140, '#ECF0F1', 'Pure frozen crystalline'),
    (7, 'thunder', 140, 280, '#F1C40F', 'Electric storm energy'),
    (8, 'ultimate', 150, 300, '#8E44AD', 'The highest form'),
    (9, 'sword', 160, 320, '#95A5A6', 'Blade of cutting truth'),
    (10, 'destruction', 170, 340, '#C0392B', 'Force of entropy'),
    (11, 'earth', 90, 180, '#27AE60', 'Grounding foundation'),
    (12, 'galaxy', 180, 360, '#3498DB', 'Cosmic expanse'),
    (13, 'create', 100, 200, '#16A085', 'Power of generation'),
    (14, 'supernova', 200, 400, '#E67E22', 'Stellar explosion'),
    (15, 'world', 250, 500, '#9B59B6', 'Reality itself')
 ON CONFLICT (id) DO NOTHING;
 -- Create function for updating updated_at timestamp
 CREATE OR REPLACE FUNCTION update_updated_at_column()
 RETURNS TRIGGER AS $$
 BEGIN
    NEW.updated_at = NOW();
    RETURN NEW;
 END;
 $$ language 'plpgsql';
 -- Create trigger for updating users.updated_at
 CREATE TRIGGER trigger_users_updated_at
    BEFORE UPDATE ON users
    FOR EACH ROW
    EXECUTE FUNCTION update_updated_at_column();
--- a/migrations/sqlite/001_initial.sql
+++ b/migrations/sqlite/001_initial.sql
@@ -0,0 +1,130 @@
 -- SQLite migration for ai.card database schema
 -- Create custom types (SQLite uses CHECK constraints instead of ENUMs)
 -- Card rarity levels
 CREATE TABLE IF NOT EXISTS card_rarity_enum (
    value TEXT PRIMARY KEY CHECK (value IN ('normal', 'rare', 'super_rare', 'kira', 'unique'))
 );
 INSERT OR IGNORE INTO card_rarity_enum (value) VALUES 
    ('normal'), ('rare'), ('super_rare'), ('kira'), ('unique');
 -- Users table - stores atproto DID-based user information
 CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    did TEXT NOT NULL UNIQUE,  -- atproto Decentralized Identifier
    handle TEXT NOT NULL,      -- atproto handle (e.g., alice.bsky.social)
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 CREATE INDEX IF NOT EXISTS idx_users_did ON users(did);
 CREATE INDEX IF NOT EXISTS idx_users_handle ON users(handle);
 -- Card master data - template definitions for all card types
 CREATE TABLE IF NOT EXISTS card_master (
    id INTEGER PRIMARY KEY,     -- Card ID (0-15 in current system)
    name TEXT NOT NULL,         -- Card name (e.g., "ai", "dream", "radiance")
    base_cp_min INTEGER NOT NULL,  -- Minimum base CP for this card
    base_cp_max INTEGER NOT NULL,  -- Maximum base CP for this card
    color TEXT NOT NULL,        -- Card color theme
    description TEXT NOT NULL   -- Card description/lore
 );
 -- User cards - actual card instances owned by users
 CREATE TABLE IF NOT EXISTS user_cards (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    card_id INTEGER NOT NULL,   -- References card_master.id
    cp INTEGER NOT NULL,        -- Calculated CP (base_cp * rarity_multiplier)
    status TEXT NOT NULL        -- Card rarity
        CHECK (status IN ('normal', 'rare', 'super_rare', 'kira', 'unique')),
    skill TEXT,                 -- Optional skill description
    obtained_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    is_unique BOOLEAN NOT NULL DEFAULT FALSE,
    unique_id TEXT,             -- UUID for unique cards
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    FOREIGN KEY (card_id) REFERENCES card_master(id)
 );
 CREATE INDEX IF NOT EXISTS idx_user_cards_user_id ON user_cards(user_id);
 CREATE INDEX IF NOT EXISTS idx_user_cards_card_id ON user_cards(card_id);
 CREATE INDEX IF NOT EXISTS idx_user_cards_status ON user_cards(status);
 CREATE INDEX IF NOT EXISTS idx_user_cards_unique_id ON user_cards(unique_id);
 -- Global unique card registry - tracks ownership of unique cards
 CREATE TABLE IF NOT EXISTS unique_card_registry (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    unique_id TEXT NOT NULL UNIQUE,    -- UUID from user_cards.unique_id
    card_id INTEGER NOT NULL,          -- Which card type is unique
    owner_did TEXT NOT NULL,           -- Current owner's atproto DID
    obtained_at DATETIME NOT NULL,
    verse_skill_id TEXT,               -- Optional verse skill reference
    FOREIGN KEY (card_id) REFERENCES card_master(id),
    UNIQUE(card_id)  -- Only one unique per card_id allowed
 );
 CREATE INDEX IF NOT EXISTS idx_unique_registry_card_id ON unique_card_registry(card_id);
 CREATE INDEX IF NOT EXISTS idx_unique_registry_owner_did ON unique_card_registry(owner_did);
 -- Draw history - tracks all gacha draws for statistics
 CREATE TABLE IF NOT EXISTS draw_history (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    card_id INTEGER NOT NULL,
    status TEXT NOT NULL
        CHECK (status IN ('normal', 'rare', 'super_rare', 'kira', 'unique')),
    cp INTEGER NOT NULL,
    is_paid BOOLEAN NOT NULL DEFAULT FALSE,  -- Paid vs free gacha
    drawn_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    FOREIGN KEY (card_id) REFERENCES card_master(id)
 );
 CREATE INDEX IF NOT EXISTS idx_draw_history_user_id ON draw_history(user_id);
 CREATE INDEX IF NOT EXISTS idx_draw_history_drawn_at ON draw_history(drawn_at);
 CREATE INDEX IF NOT EXISTS idx_draw_history_status ON draw_history(status);
 -- Gacha pools - special event pools with rate-ups
 CREATE TABLE IF NOT EXISTS gacha_pools (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    description TEXT NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    start_at DATETIME,
    end_at DATETIME,
    pickup_card_ids TEXT,              -- JSON array of card IDs
    rate_up_multiplier REAL NOT NULL DEFAULT 1.0
 );
 CREATE INDEX IF NOT EXISTS idx_gacha_pools_active ON gacha_pools(is_active);
 CREATE INDEX IF NOT EXISTS idx_gacha_pools_dates ON gacha_pools(start_at, end_at);
 -- Insert default card master data (0-15 cards from ai.json)
 INSERT OR IGNORE INTO card_master (id, name, base_cp_min, base_cp_max, color, description) VALUES
    (0, 'ai', 100, 200, '#4A90E2', 'The core essence of existence'),
    (1, 'dream', 90, 180, '#9B59B6', 'Visions of possibility'),
    (2, 'radiance', 110, 220, '#F39C12', 'Brilliant light energy'),
    (3, 'neutron', 120, 240, '#34495E', 'Dense stellar core'),
    (4, 'sun', 130, 260, '#E74C3C', 'Solar radiance'),
    (5, 'night', 80, 160, '#2C3E50', 'Darkness and mystery'),
    (6, 'snow', 70, 140, '#ECF0F1', 'Pure frozen crystalline'),
    (7, 'thunder', 140, 280, '#F1C40F', 'Electric storm energy'),
    (8, 'ultimate', 150, 300, '#8E44AD', 'The highest form'),
    (9, 'sword', 160, 320, '#95A5A6', 'Blade of cutting truth'),
    (10, 'destruction', 170, 340, '#C0392B', 'Force of entropy'),
    (11, 'earth', 90, 180, '#27AE60', 'Grounding foundation'),
    (12, 'galaxy', 180, 360, '#3498DB', 'Cosmic expanse'),
    (13, 'create', 100, 200, '#16A085', 'Power of generation'),
    (14, 'supernova', 200, 400, '#E67E22', 'Stellar explosion'),
    (15, 'world', 250, 500, '#9B59B6', 'Reality itself');
 -- Create trigger for updating users.updated_at
 CREATE TRIGGER IF NOT EXISTS trigger_users_updated_at
    AFTER UPDATE ON users
    BEGIN
        UPDATE users SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
    END;
--- a/package.json
+++ b/package.json
@@ -1,22 +0,0 @@
 {
  "name": "atr-web",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "serve": "vue-cli-service serve",
    "build": "vue-cli-service build",
    "lint": "vue-cli-service lint"
  },
  "dependencies": {
    "axios": "^0.25.0",
    "core-js": "^3.6.4",
    "moment": "^2.29.4",
    "superagent": "^8.0.9",
    "vue": "^2.6.11",
    "vue-loading-template": "^1.3.2",
    "vue-template-compiler": "^2.6.14"
  },
  "devDependencies": {
    "@vue/cli-service": "~4.5.15"
  }
 }
--- a/public/CNAME
+++ b/public/CNAME
@@ -1 +0,0 @@
 at.syui.ai
--- a/public/card/card.json
+++ b/public/card/card.json
@@ -1,80 +0,0 @@
 [
  {
    "id": 0,
    "h": "創造",
    "src": "89",
    "cid": "bafkreibh4nmdgyzvjvkhek2ultx4lsrrq2dnc7z2lqbua2ik47xo2zgkru"
  },
  {
    "id": 1,
    "h": "夢幻",
    "src": "100",
    "cid": "bafkreiajf5lblrojyo7vcqdhiqgbhd5eaj3u47mvvqf63kvexwfwphpx2y"
  },
  {
    "id": 2,
    "h": "光輝",
    "src": "109",
    "cid": "bafkreieywv4thvjrwbcf2dcol4svwmculf5qm2kvjtu2ywyyh56c7swi64"
  },
  {
    "id": 3,
    "h": "中性子",
    "src": "88",
    "cid": "bafkreieuphzhesuoqouszzwuv3iw7d5nz4eamlqc2csfv26d5vmcdg2qby"
  },
  {
    "id": 4,
    "h": "太陽",
    "src": "59",
    "cid": "bafkreifw7f44ldmi7bufs5rzwftjvgmsflekkvxazqns63venm7hqnql3q"
  },
  {
    "id": 5,
    "h": "夜空",
    "src": "112",
    "cid": "bafkreicuieuz6wjva7l7t2u5n46izxs7nku6tedlgtlgkabszjz5dn3yl4"
  },
  {
    "id": 6,
    "h": "白雪",
    "src": "15",
    "cid": "bafkreihl5ifvl3ougbfdjfdjwrhdjrncqm5opj65cteow5f2aj7p6nz42y"
  },
  {
    "id": 7,
    "h": "雷帝",
    "src": "30",
    "cid": "bafkreihylxc22kfcb3bereypl6tvqkiqtazod3tp7vbze7yxdqedwli6z4"
  },
  {
    "id": 8,
    "h": "超究",
    "src": "108",
    "cid": "bafkreieq4tdiq72tsbvqv5bnitd5sj5bbvtmee5off3k4nvl7za3plhj5m"
  },
  {
    "id": 9,
    "h": "剣技",
    "src": "103",
    "cid": "bafkreig2uzf5cyn5fty5ftumd6wyg7vf5wry37h4v4mmorkx5msvn3uqvu"
  },
  {
    "id": 10,
    "h": "破壊",
    "src": "87",
    "cid": "bafkreifcos5ur6y753jepmy4ttgylasvcyk5osguzlaojcnlrshl3q6k3a"
  },
  {
    "id": 11,
    "h": "地球",
    "src": "78",
    "cid": "bafkreigpxxkzz2oesnb2mnfe42nrgk57wnr73ssn5luriy3j25mij43uki"
  },
  {
    "id": 12,
    "h": "天ノ川",
    "src": "115",
    "cid": "bafkreiefcjjplklmo6wrc7pq23yaewg2zgjm7nsmjy5q7mut2dnxydomnm"
  }
 ]
--- a/public/card/card_0.jpg
+++ b/public/card/card_0.jpg
--- a/public/card/card_0.png
+++ b/public/card/card_0.png
--- a/public/card/card_0.webp
+++ b/public/card/card_0.webp
--- a/public/card/card_1.jpg
+++ b/public/card/card_1.jpg
--- a/public/card/card_1.png
+++ b/public/card/card_1.png
--- a/public/card/card_1.webp
+++ b/public/card/card_1.webp
--- a/public/card/card_10.jpg
+++ b/public/card/card_10.jpg
--- a/public/card/card_10.png
+++ b/public/card/card_10.png
--- a/public/card/card_10.webp
+++ b/public/card/card_10.webp
--- a/public/card/card_11.jpg
+++ b/public/card/card_11.jpg
--- a/public/card/card_11.png
+++ b/public/card/card_11.png
--- a/public/card/card_11.webp
+++ b/public/card/card_11.webp
--- a/public/card/card_12.jpg
+++ b/public/card/card_12.jpg
--- a/public/card/card_12.png
+++ b/public/card/card_12.png
--- a/public/card/card_12.webp
+++ b/public/card/card_12.webp
--- a/public/card/card_2.jpg
+++ b/public/card/card_2.jpg
--- a/public/card/card_2.png
+++ b/public/card/card_2.png
--- a/public/card/card_2.webp
+++ b/public/card/card_2.webp
--- a/public/card/card_3.jpg
+++ b/public/card/card_3.jpg
--- a/public/card/card_3.png
+++ b/public/card/card_3.png
--- a/public/card/card_3.webp
+++ b/public/card/card_3.webp
--- a/public/card/card_4.jpg
+++ b/public/card/card_4.jpg
--- a/public/card/card_4.png
+++ b/public/card/card_4.png
--- a/public/card/card_4.webp
+++ b/public/card/card_4.webp
--- a/public/card/card_5.jpg
+++ b/public/card/card_5.jpg
--- a/public/card/card_5.png
+++ b/public/card/card_5.png
--- a/public/card/card_5.webp
+++ b/public/card/card_5.webp
--- a/public/card/card_6.jpg
+++ b/public/card/card_6.jpg
--- a/public/card/card_6.png
+++ b/public/card/card_6.png
--- a/public/card/card_6.webp
+++ b/public/card/card_6.webp
--- a/public/card/card_7.jpg
+++ b/public/card/card_7.jpg
--- a/public/card/card_7.png
+++ b/public/card/card_7.png
--- a/public/card/card_7.webp
+++ b/public/card/card_7.webp
--- a/public/card/card_8.jpg
+++ b/public/card/card_8.jpg
--- a/public/card/card_8.png
+++ b/public/card/card_8.png
--- a/public/card/card_8.webp
+++ b/public/card/card_8.webp
--- a/public/card/card_9.jpg
+++ b/public/card/card_9.jpg
--- a/public/card/card_9.png
+++ b/public/card/card_9.png
--- a/public/card/card_9.webp
+++ b/public/card/card_9.webp
--- a/public/card/t.zsh
+++ b/public/card/t.zsh
@@ -1,21 +0,0 @@
 #!/bin/zsh
 d=${0:a:h}
 j=$d/card.json
 n=`cat $j|jq length`
 n=$((n - 1))
 for ((i=0;i<=$n;i++))
 do
 	t=`cat $j|jq ".[$i].cid"`
 	id=`cat $j|jq ".[$i].id"`
 	f=card_${id}.webp
 	if ls $f;then
 		cid=`atr img-upload $f|head -n 1`
 		echo $cid
 		if cat $j |jq ".[$i]|= .+ {\"cid\":\"$cid\"}";then
 			cat $j |jq ".[$i]|= .+ {\"cid\":\"$cid\"}" >! $j.back
 			mv $j.back $j
 			cat $j|jq ".[$i]"
 		fi
 	fi
 done
--- a/public/chara/ai.png
+++ b/public/chara/ai.png
--- a/public/chara/drai.png
+++ b/public/chara/drai.png
--- a/public/chara/kyosuke.png
+++ b/public/chara/kyosuke.png
--- a/public/chara/mr.png
+++ b/public/chara/mr.png
--- a/public/chara/neko.png
+++ b/public/chara/neko.png
--- a/public/chara/octkat.png
+++ b/public/chara/octkat.png
--- a/public/chara/papas.png
+++ b/public/chara/papas.png
--- a/public/chara/plan.png
+++ b/public/chara/plan.png
--- a/public/chara/ponta.png
+++ b/public/chara/ponta.png
--- a/public/chara/zen.png
+++ b/public/chara/zen.png
--- a/public/image/1gNGwD6W74qb_Nuncr5H5i9UADEtdyds9myxRGnkGMw/rs:fill:1000:1000:1:0/plain/bafkreibxgpwttqvpsnn5yrvqkx47nwuzpzrkfyladqy2hbj3chedph3fni@jpeg
+++ b/public/image/1gNGwD6W74qb_Nuncr5H5i9UADEtdyds9myxRGnkGMw/rs:fill:1000:1000:1:0/plain/bafkreibxgpwttqvpsnn5yrvqkx47nwuzpzrkfyladqy2hbj3chedph3fni@jpeg
--- a/public/image/G8UWSR-zF7dJQP-wEhlMfUwzUmdX6v6J4mxA5cQZ7mE/rs:fill:1000:1000:1:0/plain/bafkreicltsmeatkmq5wkx5ge6nz73ol2wrf5fa5gkymxmuahzfytyjrvze@jpeg
+++ b/public/image/G8UWSR-zF7dJQP-wEhlMfUwzUmdX6v6J4mxA5cQZ7mE/rs:fill:1000:1000:1:0/plain/bafkreicltsmeatkmq5wkx5ge6nz73ol2wrf5fa5gkymxmuahzfytyjrvze@jpeg
--- a/public/image/vEPdhP659vrk0CqxpzvOvoc0ZnIlsAAxhmoUS3Am2KU/rs:fill:1000:1000:1:0/plain/bafkreihl4namtpjtx2a3hqdepgwvdgvhb4sfc37tg4dho4loolntmzp57a@jpeg
+++ b/public/image/vEPdhP659vrk0CqxpzvOvoc0ZnIlsAAxhmoUS3Am2KU/rs:fill:1000:1000:1:0/plain/bafkreihl4namtpjtx2a3hqdepgwvdgvhb4sfc37tg4dho4loolntmzp57a@jpeg
--- a/public/image/yxvjT3Q1W4xjQXO5knVPFXcCGJNHLCAaFgO8cJnnV18/rs:fill:3000:1000:1:0/plain/bafkreid4lykfei4rz262s6gn6popexr7bgtb2gskqpn3or3cxdvi3bxv7e@jpeg
+++ b/public/image/yxvjT3Q1W4xjQXO5knVPFXcCGJNHLCAaFgO8cJnnV18/rs:fill:3000:1000:1:0/plain/bafkreid4lykfei4rz262s6gn6popexr7bgtb2gskqpn3or3cxdvi3bxv7e@jpeg
--- a/public/index.html
+++ b/public/index.html
@@ -1 +0,0 @@
 <!DOCTYPE html><html lang=""><head><title><%= htmlWebpackPlugin.options.title %></title><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Vue App</title><link href="app.css" rel="preload" as="style"><link href="app.js" rel="preload" as="script"><link href="chunk-vendors.js" rel="preload" as="script"><link href="app.css" rel="stylesheet"></head><body><div id="app"></div><script src="chunk-vendors.js"></script><script src="app.js"></script></body></html>
--- a/public/json/syui.syui.ai.json
+++ b/public/json/syui.syui.ai.json
@@ -1,20 +0,0 @@
 {
  "did": "did:plc:schldsdljwxcdtslnbqaoifh",
  "declaration": {
    "actorType": "app.bsky.system.actorUser",
    "cid": "bafyreid27zk7lbis4zw5fz4podbvbs4fc5ivwji3dmrwa6zggnj4bnd57u"
  },
  "handle": "syui.syui.ai",
  "avatar": "https://at.syui.ai/image/1gNGwD6W74qb_Nuncr5H5i9UADEtdyds9myxRGnkGMw/rs:fill:1000:1000:1:0/plain/bafkreibxgpwttqvpsnn5yrvqkx47nwuzpzrkfyladqy2hbj3chedph3fni@jpeg",
  "followsCount": 0,
  "followersCount": 1,
  "postsCount": 1,
  "creator": "did:plc:schldsdljwxcdtslnbqaoifh",
  "indexedAt": "2023-03-21T08:23:26.046Z",
  "viewer": {
    "muted": false
  },
  "myState": {
    "muted": false
  }
 }
--- a/src/App.vue
+++ b/src/App.vue
@@ -1,132 +0,0 @@
 <template>
 	<div id="app">
 		<form @submit.prevent="submit">
 			<input v-model="id" placeholder="id" value="id">
 			<input type="submit">
 		</form> 
 		<div v-if="cards" class="bluesky-card">
 			<h3>{{ user.data.username }} card list</h3>
 			<span  v-for="ii in cards.data">
 				<img :src='"https://at.syui.ai/card/card_" + ii.card + ".png"'/>{{ ii.cp }}
 			</span>
 		</div>
 	<div v-if="record" class="bluesky-record">
 		<li v-for="i in record.data">
 			<p><span class="text">id : {{ i.id }}</span></p>
 			<p><span class="text">{{ i.username }}</span></p>
 		</li>
 	</div>
 	</div>
 </template>
 <script>
 import axios from 'axios'
 let default_id = "syui.syui.ai";
 export default {
 	name: "App",
 	metaInfo: {
 		title: "syui.ai",
 	},
 	data () {
 		return {
 			card: null,
 			cards: null,
 			id: null,
 			record: null,
 			url: null,
 			user: null,
 		}
 	},
 	mounted() {
 		axios.get("https://cors-card.herokuapp.com/https://api.syui.ai/users",{ crossdomain: true })
 			.then(response => (this.record = response))
 			.catch(error => console.log(error));
 	},
 	methods: {
 		submit() {
 			let url = "https://cors-card.herokuapp.com/https://api.syui.ai/users/" + this.id + "/card";
 			axios
 				.get(url,{ crossdomain: true })
 				.then(response => (this.cards = response));
 				axios
 					.get("https://cors-card.herokuapp.com/https://api.syui.ai/users/" + this.id,{ crossdomain: true })
 					.then(response => (this.user = response));
 		},
 		draw(id) {
 			let url = "https://cors-card.herokuapp.com/https://api.syui.ai/users/" + id + "/card";
 			axios
 				.get(url,{ crossdomain: true })
 				.then(response => (this.cards = response));
 		}
 	},
 }
 </script>
 <style>
 div#app {
 	list-style: none;
 	margin: 100px;
 }
 .bluesky-avatar img {
 	width: 55px;
 }
 span.time {
 	color: blue;
 }
 span.name {
 	font-weight: 700;
 	background-color: #a3c3ff1a;
 	padding:10px;
 }
 span.text {
 	font-weight: 400;
 	font-size: 19px;
 }
 .bluesky-record li {
 	border-bottom: solid 1px #ccc;
 }
 .bluesky-record p {
 	padding:0 20px 0;
 }
 .bluesky-record {
 	border: solid 1px #ccc;
 	border-radius: 10px;
 	margin: 50px 100px 0 0;
 }
 a {
 	color: #00A4E1;
 	font-weight: '700';
 }
 footer#footer {
 	text-align: center;
 }
 span.text {
 	word-break: break-all;
 }
 p.tl-avatar img {
 	width: 20px;
 }
 img {
 	width: 50px;
 	margin:10px;
 }
 code {
 	font-size: 15px;
 	/*color: #3f89ff;*/
 	padding: 5px 5px 5px 5px;
 	background-color: #d4deee2b;
 }
 li {
 	list-style-type: none; 
 }
@media screen and (max-width:1000px) { 
 	div#app{list-style:none;margin:0px}.bluesky-avatar img{width:55px}span.time{color:#00f}span.name{background-color:rgba(163,195,255,.10196078431372549);padding:10px}.bluesky-record li{border-bottom:1px solid #ccc}.bluesky-record p{padding:0 20px 0}.bluesky-record{border:1px solid #ccc;border-radius:10px;margin:0px 0px 0 0}a{color:#3f89ff}footer#footer{text-align:center}
 	span.text {
 		word-break: break-all;
 	}
 }
 </style>
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -0,0 +1,108 @@
 use chrono::{Duration, Utc};
 use jsonwebtoken::{decode, encode, DecodingKey, EncodingKey, Header, Validation};
 use serde::{Deserialize, Serialize};
 use crate::error::{AppError, AppResult};
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Claims {
    pub did: String,
    pub handle: String,
    pub exp: usize,
 }
 pub struct JwtService {
    encoding_key: EncodingKey,
    decoding_key: DecodingKey,
 }
 impl JwtService {
    pub fn new(secret: &str) -> Self {
        Self {
            encoding_key: EncodingKey::from_secret(secret.as_ref()),
            decoding_key: DecodingKey::from_secret(secret.as_ref()),
        }
    }
    pub fn create_token(&self, did: &str, handle: &str, expires_in_minutes: u64) -> AppResult<String> {
        let expiration = Utc::now()
            .checked_add_signed(Duration::minutes(expires_in_minutes as i64))
            .ok_or_else(|| AppError::internal("Failed to calculate expiration time"))?
            .timestamp() as usize;
        let claims = Claims {
            did: did.to_string(),
            handle: handle.to_string(),
            exp: expiration,
        };
        encode(&Header::default(), &claims, &self.encoding_key)
            .map_err(AppError::Jwt)
    }
    pub fn verify_token(&self, token: &str) -> AppResult<Claims> {
        let token_data = decode::<Claims>(token, &self.decoding_key, &Validation::default())
            .map_err(AppError::Jwt)?;
        Ok(token_data.claims)
    }
 }
 /// Mock atproto authentication service
 /// In a real implementation, this would integrate with actual atproto services
 pub struct AtprotoAuthService {
    jwt_service: JwtService,
 }
 impl AtprotoAuthService {
    pub fn new(secret: &str) -> Self {
        Self {
            jwt_service: JwtService::new(secret),
        }
    }
    /// Authenticate user with atproto credentials
    /// This is a mock implementation - in reality would validate against atproto PDS
    pub async fn authenticate(&self, identifier: &str, _password: &str) -> AppResult<AuthenticatedUser> {
        // Mock validation - in real implementation:
        // 1. Connect to user's PDS
        // 2. Verify credentials
        // 3. Get user DID and handle
        // For now, treat identifier as DID or handle
        let (did, handle) = if identifier.starts_with("did:") {
            (identifier.to_string(), extract_handle_from_did(identifier))
        } else {
            (format!("did:plc:{}", generate_mock_plc_id()), identifier.to_string())
        };
        Ok(AuthenticatedUser { did, handle })
    }
    pub fn create_access_token(&self, user: &AuthenticatedUser, expires_in_minutes: u64) -> AppResult<String> {
        self.jwt_service.create_token(&user.did, &user.handle, expires_in_minutes)
    }
    pub fn verify_access_token(&self, token: &str) -> AppResult<Claims> {
        self.jwt_service.verify_token(token)
    }
 }
 #[derive(Debug, Clone)]
 pub struct AuthenticatedUser {
    pub did: String,
    pub handle: String,
 }
 /// Extract handle from DID (mock implementation)
 fn extract_handle_from_did(did: &str) -> String {
    // In a real implementation, this would resolve the DID to get the handle
    // For now, use a simple mock
    did.split(':').last().unwrap_or("unknown").to_string()
 }
 /// Generate mock PLC identifier
 fn generate_mock_plc_id() -> String {
    use uuid::Uuid;
    Uuid::new_v4().to_string().replace('-', "")[..24].to_string()
 }
--- a/src/config.rs
+++ b/src/config.rs
@@ -0,0 +1,131 @@
 use config::{Config, ConfigError, Environment, File};
 use serde::Deserialize;
 use std::path::PathBuf;
 #[derive(Debug, Clone, Deserialize)]
 pub struct Settings {
    // Application settings
    pub app_name: String,
    pub port: u16,
    pub api_v1_prefix: String,
    // Database settings
    pub database_url: String,
    pub database_url_supabase: Option<String>,
    // Authentication
    pub secret_key: String,
    pub access_token_expire_minutes: u64,
    // Gacha probabilities (percentages)
    pub prob_normal: f64,
    pub prob_rare: f64,
    pub prob_super_rare: f64,
    pub prob_kira: f64,
    pub prob_unique: f64,
    // atproto settings
    pub atproto_pds_url: Option<String>,
    pub atproto_handle: Option<String>,
    // External data
    pub card_master_url: String,
    // File paths
    pub config_dir: PathBuf,
 }
 impl Settings {
    pub fn new() -> Result<Self, ConfigError> {
        let config_dir = dirs::home_dir()
            .unwrap_or_else(|| PathBuf::from("."))
            .join(".config")
            .join("syui")
            .join("ai")
            .join("card");
        // Ensure config directory exists
        if !config_dir.exists() {
            std::fs::create_dir_all(&config_dir)
                .map_err(|e| ConfigError::Message(format!("Failed to create config directory: {}", e)))?;
        }
        let mut builder = Config::builder()
            // Default values
            .set_default("app_name", "ai.card")?
            .set_default("port", 8000)?
            .set_default("api_v1_prefix", "/api/v1")?
            // Database defaults
            .set_default("database_url", format!("sqlite://{}?mode=rwc", config_dir.join("aicard.db").display()))?
            // Authentication defaults
            .set_default("secret_key", "your-secret-key-change-in-production")?
            .set_default("access_token_expire_minutes", 1440)? // 24 hours
            // Gacha probability defaults (matching Python implementation)
            .set_default("prob_normal", 99.789)?
            .set_default("prob_rare", 0.1)?
            .set_default("prob_super_rare", 0.01)?
            .set_default("prob_kira", 0.1)?
            .set_default("prob_unique", 0.0001)?
            // External data source
            .set_default("card_master_url", "https://git.syui.ai/ai/ai/raw/branch/main/ai.json")?;
        // Load from config file if it exists (support both .toml and .json)
        let config_toml = config_dir.join("config.toml");
        let config_json = config_dir.join("config.json");
        if config_toml.exists() {
            builder = builder.add_source(File::from(config_toml));
        } else if config_json.exists() {
            builder = builder.add_source(File::from(config_json));
        }
        // Override with environment variables (AI_CARD_ prefix)
        builder = builder.add_source(Environment::with_prefix("AI_CARD").separator("_"));
        let mut settings: Settings = builder.build()?.try_deserialize()?;
        // Set the config directory path
        settings.config_dir = config_dir;
        Ok(settings)
    }
    /// Get the gacha configuration for the gacha service
    pub fn gacha_config(&self) -> GachaConfig {
        GachaConfig {
            prob_normal: self.prob_normal,
            prob_rare: self.prob_rare,
            prob_super_rare: self.prob_super_rare,
            prob_kira: self.prob_kira,
            prob_unique: self.prob_unique,
        }
    }
 }
 #[derive(Debug, Clone)]
 pub struct GachaConfig {
    pub prob_normal: f64,
    pub prob_rare: f64,
    pub prob_super_rare: f64,
    pub prob_kira: f64,
    pub prob_unique: f64,
 }
 impl GachaConfig {
    /// Calculate cumulative probabilities for rarity determination
    pub fn cumulative_probabilities(&self, is_paid: bool) -> Vec<(f64, crate::models::CardRarity)> {
        let multiplier = if is_paid { 2.0 } else { 1.0 };
        vec![
            (self.prob_unique * multiplier, crate::models::CardRarity::Unique),
            (self.prob_kira * multiplier, crate::models::CardRarity::Kira),
            (self.prob_super_rare * multiplier, crate::models::CardRarity::SuperRare),
            (self.prob_rare * multiplier, crate::models::CardRarity::Rare),
            (self.prob_normal, crate::models::CardRarity::Normal),
        ]
    }
 }
--- a/src/database.rs
+++ b/src/database.rs
@@ -0,0 +1,189 @@
 use sqlx::{Pool, Postgres, Sqlite};
 use sqlx::migrate::MigrateDatabase;
 use crate::error::{AppError, AppResult};
 #[derive(Clone)]
 pub enum Database {
    Postgres(Pool<Postgres>),
    Sqlite(Pool<Sqlite>),
 }
 impl Database {
    pub async fn connect(database_url: &str) -> AppResult<Self> {
        if database_url.starts_with("postgres://") || database_url.starts_with("postgresql://") {
            let pool = sqlx::postgres::PgPoolOptions::new()
                .max_connections(10)
                .connect(database_url)
                .await
                .map_err(AppError::Database)?;
            Ok(Database::Postgres(pool))
        } else if database_url.starts_with("sqlite://") {
            // Extract the path from sqlite:// URL
            let _db_path = database_url.trim_start_matches("sqlite://");
            // Create the database file if it doesn't exist
            if !Sqlite::database_exists(database_url).await.unwrap_or(false) {
                Sqlite::create_database(database_url)
                    .await
                    .map_err(AppError::Database)?;
            }
            let pool = sqlx::sqlite::SqlitePoolOptions::new()
                .max_connections(5)
                .connect(database_url)
                .await
                .map_err(AppError::Database)?;
            Ok(Database::Sqlite(pool))
        } else {
            Err(AppError::Configuration(format!(
                "Unsupported database URL: {}",
                database_url
            )))
        }
    }
    pub async fn migrate(&self) -> AppResult<()> {
        match self {
            Database::Postgres(pool) => {
                sqlx::migrate!("./migrations/postgres")
                    .run(pool)
                    .await
                    .map_err(AppError::Migration)?;
            }
            Database::Sqlite(pool) => {
                sqlx::migrate!("./migrations/sqlite")
                    .run(pool)
                    .await
                    .map_err(AppError::Migration)?;
            }
        }
        Ok(())
    }
    /// Get a generic connection for complex operations
    pub async fn acquire(&self) -> AppResult<DatabaseConnection> {
        match self {
            Database::Postgres(pool) => {
                let conn = pool.acquire().await.map_err(AppError::Database)?;
                Ok(DatabaseConnection::Postgres(conn))
            }
            Database::Sqlite(pool) => {
                let conn = pool.acquire().await.map_err(AppError::Database)?;
                Ok(DatabaseConnection::Sqlite(conn))
            }
        }
    }
    /// Begin a transaction
    pub async fn begin(&self) -> AppResult<DatabaseTransaction> {
        match self {
            Database::Postgres(pool) => {
                let tx = pool.begin().await.map_err(AppError::Database)?;
                Ok(DatabaseTransaction::Postgres(tx))
            }
            Database::Sqlite(pool) => {
                let tx = pool.begin().await.map_err(AppError::Database)?;
                Ok(DatabaseTransaction::Sqlite(tx))
            }
        }
    }
 }
 pub enum DatabaseConnection {
    Postgres(sqlx::pool::PoolConnection<Postgres>),
    Sqlite(sqlx::pool::PoolConnection<Sqlite>),
 }
 pub enum DatabaseTransaction {
    Postgres(sqlx::Transaction<'static, Postgres>),
    Sqlite(sqlx::Transaction<'static, Sqlite>),
 }
 impl DatabaseTransaction {
    pub async fn commit(self) -> AppResult<()> {
        match self {
            DatabaseTransaction::Postgres(tx) => {
                tx.commit().await.map_err(AppError::Database)?;
            }
            DatabaseTransaction::Sqlite(tx) => {
                tx.commit().await.map_err(AppError::Database)?;
            }
        }
        Ok(())
    }
    pub async fn rollback(self) -> AppResult<()> {
        match self {
            DatabaseTransaction::Postgres(tx) => {
                tx.rollback().await.map_err(AppError::Database)?;
            }
            DatabaseTransaction::Sqlite(tx) => {
                tx.rollback().await.map_err(AppError::Database)?;
            }
        }
        Ok(())
    }
 }
 // Macros for database-agnostic queries
 #[macro_export]
 macro_rules! query_as {
    ($struct:ty, $query:expr, $db:expr) => {
        match $db {
            Database::Postgres(pool) => {
                sqlx::query_as::<_, $struct>($query)
                    .fetch_all(pool)
                    .await
                    .map_err(AppError::Database)
            }
            Database::Sqlite(pool) => {
                sqlx::query_as::<_, $struct>($query)
                    .fetch_all(pool)
                    .await
                    .map_err(AppError::Database)
            }
        }
    };
 }
 #[macro_export]
 macro_rules! query_one_as {
    ($struct:ty, $query:expr, $db:expr) => {
        match $db {
            Database::Postgres(pool) => {
                sqlx::query_as::<_, $struct>($query)
                    .fetch_one(pool)
                    .await
                    .map_err(AppError::Database)
            }
            Database::Sqlite(pool) => {
                sqlx::query_as::<_, $struct>($query)
                    .fetch_one(pool)
                    .await
                    .map_err(AppError::Database)
            }
        }
    };
 }
 #[macro_export]
 macro_rules! query_optional_as {
    ($struct:ty, $query:expr, $db:expr) => {
        match $db {
            Database::Postgres(pool) => {
                sqlx::query_as::<_, $struct>($query)
                    .fetch_optional(pool)
                    .await
                    .map_err(AppError::Database)
            }
            Database::Sqlite(pool) => {
                sqlx::query_as::<_, $struct>($query)
                    .fetch_optional(pool)
                    .await
                    .map_err(AppError::Database)
            }
        }
    };
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
syui	142a5ac135	fix cargo	2025-06-09 03:58:38 +09:00
syui	5ae075edd3	clean	2025-06-09 02:53:50 +09:00
syui	0b34568585	Add complete ai.card Rust implementation - Implement complete Rust API server with axum framework - Add database abstraction supporting PostgreSQL and SQLite - Implement comprehensive gacha system with probability calculations - Add JWT authentication with atproto DID integration - Create card master data system with rarities (Normal, Rare, SuperRare, Kira, Unique) - Implement draw history tracking and collection management - Add API endpoints for authentication, card drawing, and collection viewing - Include database migrations for both PostgreSQL and SQLite - Maintain full compatibility with Python API implementation - Add comprehensive documentation and development guide 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-06-09 01:51:15 +09:00
syui	ef907660cc	fix gpt	2025-06-09 01:51:15 +09:00
syui	6cd8014f80	merge aigpt	2025-06-02 18:24:43 +09:00
syui	6dbe630b9d	fix config	2025-06-02 00:39:26 +09:00
syui	67145cd342	fix	2025-06-02 00:32:14 +09:00
syui	4246f718ef	add claude	2025-06-01 21:39:53 +09:00
syui	3459231bba	fix	2025-06-01 16:43:12 +09:00
syui	725783bbca	fix	2025-04-29 15:28:05 +09:00
syui	f6676e4e25	fix	2024-12-09 04:40:48 +09:00
syui	52326ec57f	fix	2024-12-01 00:32:18 +09:00
syui	f078e96d67	fix	2024-10-16 22:55:40 +09:00
syui	c2f1f33542	fix	2024-10-16 22:49:22 +09:00
syui	1bdf3153a4	fix	2024-10-05 14:59:54 +09:00
syui	edadefc7c0	fix	2024-10-05 14:17:56 +09:00
syui	1197f18bd2	fix	2024-10-04 13:38:34 +09:00
syui	6879eaad3c	fix	2024-10-02 15:03:32 +09:00
syui	5c9377a988	fix	2024-10-02 13:38:49 +09:00
syui	b21cb8dfa0	fix	2024-10-02 13:33:32 +09:00
syui	0a658ff9d4	fix	2024-10-02 13:17:30 +09:00
syui	cdda79ba5e	fix	2024-10-02 12:57:56 +09:00
syui	e622dac696	fix	2024-09-07 20:51:42 +09:00
syui	18372b2970	fix	2024-09-07 20:35:00 +09:00
syui	0e3febe1ed	fix	2024-08-12 18:01:33 +09:00
syui	e6e5baf628	fix	2024-08-06 22:03:47 +09:00
syui	4394ff935d	fix	2024-08-06 17:55:51 +09:00
syui	9b6fef0215	fix	2024-08-06 16:46:53 +09:00
syui	335ca5ee0e	fix	2024-08-05 19:22:06 +09:00
syui	8884dc669e	fix	2024-08-05 19:09:45 +09:00
syui	b37fd46126	fi	2024-08-03 23:11:44 +09:00
syui	d73aaccff3	fix	2024-08-03 22:57:06 +09:00
syui	67cc116a84	iframe load	2024-08-03 19:05:06 +09:00
syui	dc0ec301e7	add planet	2024-08-03 18:58:40 +09:00
syui	a1a7ddd202	add seven	2024-04-23 17:38:19 +09:00
syui	1b34aa294c	add file	2024-04-11 07:53:10 +09:00
		`@@ -1 +0,0 @@`
			<!DOCTYPE html><html lang=""><head><title><%= htmlWebpackPlugin.options.title %></title><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Vue App</title><link href="app.css" rel="preload" as="style"><link href="app.js" rel="preload" as="script"><link href="chunk-vendors.js" rel="preload" as="script"><link href="app.css" rel="stylesheet"></head><body><div id="app"></div><script src="chunk-vendors.js"></script><script src="app.js"></script></body></html>