Copy to github 1st

.gitignore

@@ -0,0 +1,57 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Project specific
+generated-icon.png
+chat_export_*.md
+agent_chat_*.md
+*.log
+
+# Export directory
+export/
+
+# Dependencies
+.uv/
+.venv/
+.python-version
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Editor/OS
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Unit test / coverage reports
+.tox/
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover

.replit

@@ -0,0 +1,56 @@
+modules = ["python-3.11"]
+
+[nix]
+channel = "stable-24_05"
+
+[deployment]
+deploymentTarget = "autoscale"
+run = ["sh", "-c", "python save_chat_history.py"]
+
+[workflows]
+runButton = "Project"
+
+[[workflows.workflow]]
+name = "Project"
+mode = "parallel"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "save_history"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "save_agent_history"
+
+[[workflows.workflow]]
+name = "save_history"
+author = "agent"
+
+[workflows.workflow.metadata]
+agentRequireRestartOnSave = false
+
+[[workflows.workflow.tasks]]
+task = "packager.installForAll"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "python save_chat_history.py"
+
+[[workflows.workflow]]
+name = "save_agent_history"
+author = "agent"
+
+[workflows.workflow.metadata]
+agentRequireRestartOnSave = false
+
+[[workflows.workflow.tasks]]
+task = "packager.installForAll"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "python agent_chat_history.py"
+
+[[ports]]
+localPort = 5000
+externalPort = 80

.streamlit/config.toml

@@ -0,0 +1,34 @@
+[server]
+headless = true
+address = "0.0.0.0"
+port = 5000
+
+[theme]
+# Primary accent color for interactive elements
+primaryColor = "#FF4B4B"
+
+# Background color for the main content area
+backgroundColor = "#FFFFFF"
+
+# Background color used for the sidebar and most interactive widgets
+secondaryBackgroundColor = "#F0F2F6"
+
+# Color used for almost all text
+textColor = "#262730"
+
+# Font family for all text in the app, except code blocks
+# Accepted values (serif | sans serif | monospace) 
+# Default: "sans serif"
+font = "sans serif"
+
+# The preset Streamlit theme to use (light or dark)
+base = "light"
+
+# Background color for sidebar
+sidebarBackgroundColor = "#F0F2F6"
+
+# Background color for widgets
+widgetBackgroundColor = "#FFFFFF"
+
+[browser]
+gatherUsageStats = false

README.md

@@ -1,14 +1,120 @@
----
-title: AILanguageCompanion
-emoji: ⚡
-colorFrom: yellow
-colorTo: red
-sdk: streamlit
-sdk_version: 1.41.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: AILanguageCompanion
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MyChatMe - マルチリンガルAIチャットアプリケーション
+
+[![Built with Streamlit](https://img.shields.io/badge/built%20with-Streamlit-ff4b4b.svg)](https://www.streamlit.io)
+[![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3120/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+高度なマルチリンガルAIチャットアプリケーションで、複数の言語での対話とプロンプトテンプレート管理を実現します。
+
+[English](README_en.md) | 日本語
+
+## 🌟 主な機能
+
+- 🤖 複数のAIモデルをサポート
+  - OpenAI GPT-4
+  - Google Gemini-2.0
+  - Anthropic Claude-3.5
+- 🌐 多言語対応
+  - 日本語とEnglishのインターフェース
+  - 言語切り替え機能
+- 📝 プロンプトテンプレート管理
+  - テンプレートの保存・編集
+  - カテゴリ分類
+- 💾 チャット履歴
+  - マークダウン形式でエクスポート
+  - PDF出力対応
+- 🎨 カスタマイズ可能なテーマ
+- ⚡ レスポンシブデザイン
+
+## 🛠️ 技術スタック
+
+- **フロントエンド**: Streamlit
+- **バックエンド**: Python 3.12
+- **AI統合**:
+  - OpenAI API
+  - Google Gemini API (via OpenRouter)
+  - Anthropic Claude API (via OpenRouter)
+- **国際化**: カスタムi18nシステム
+- **データ出力**: ReportLab (PDF生成)
+
+## 📋 必要条件
+
+- Python 3.12以上
+- OpenAI APIキー
+- OpenRouter APIキー（Gemini-2.0とClaude-3.5用）
+
+## 🚀 セットアップ
+
+1. リポジトリのクローン:
+```bash
+git clone https://github.com/yourusername/mychatme.git
+cd mychatme
+```
+
+2. 依存関係のインストール:
+```bash
+pip install -r requirements.txt
+```
+
+3. 環境変数の設定:
+```bash
+# .env ファイルを作成
+OPENAI_API_KEY=your_openai_api_key
+OPENROUTER_API_KEY=your_openrouter_api_key
+```
+
+4. アプリケーションの起動:
+```bash
+streamlit run main.py
+```
+
+## 💡 使用方法
+
+1. **言語の選択**:
+   - サイドバーから日本語/英語を選択
+
+2. **AIモデルの選択**:
+   - GPT-4, Gemini-2.0, Claude-3.5から選択
+   - 各モデルの特徴に応じて使い分け
+
+3. **プロンプトテンプレート**:
+   - テンプレートの作成・保存
+   - 保存したテンプレートの呼び出し
+   - テンプレートの編集・削除
+
+4. **チャット履歴の管理**:
+   - チャット内容のエクスポート（MD/PDF）
+   - タイムゾーン対応の履歴管理
+
+5. **テーマカスタマイズ**:
+   - ライト/ダークモード
+   - カラーテーマの変更
+
+## 🔒 セキュリティ
+
+- API認証情報は環境変数で管理
+- セッション管理による安全な状態保持
+- エラーハンドリングとレート制限の実装
+
+## 🤝 貢献
+
+1. このリポジトリをフォーク
+2. 新しいブランチを作成 (`git checkout -b feature/amazing-feature`)
+3. 変更をコミット (`git commit -m 'Add amazing feature'`)
+4. ブランチにプッシュ (`git push origin feature/amazing-feature`)
+5. プルリクエストを作成
+
+## 📜 ライセンス
+
+このプロジェクトはMITライセンスの下で公開されています。詳細は [LICENSE](LICENSE) ファイルを参照してください。
+
+## 🙏 謝辞
+
+- [Streamlit](https://streamlit.io/) - 素晴らしいWebアプリケーションフレームワーク
+- [OpenAI](https://openai.com/) - GPT-4モデルの提供
+- [OpenRouter](https://openrouter.ai/) - 統合AIモデルアクセス
+- [ReportLab](https://www.reportlab.com/) - PDFエクスポート機能
+
+## 📞 サポート
+
+問題や提案がある場合は、GitHubのIssueセクションでお知らせください。

README_en.md

@@ -0,0 +1,120 @@
+# MyChatMe - Multilingual AI Chat Application
+
+[![Built with Streamlit](https://img.shields.io/badge/built%20with-Streamlit-ff4b4b.svg)](https://www.streamlit.io)
+[![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3120/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An advanced multilingual AI chat application designed to streamline cross-language communication and prompt template management.
+
+[日本語](README.md) | English
+
+## 🌟 Key Features
+
+- 🤖 Multiple AI Model Support
+  - OpenAI GPT-4
+  - Google Gemini-2.0
+  - Anthropic Claude-3.5
+- 🌐 Multilingual Support
+  - English and Japanese interfaces
+  - Language switching capability
+- 📝 Prompt Template Management
+  - Save and edit templates
+  - Category classification
+- 💾 Chat History
+  - Export as Markdown
+  - PDF output support
+- 🎨 Customizable Themes
+- ⚡ Responsive Design
+
+## 🛠️ Technology Stack
+
+- **Frontend**: Streamlit
+- **Backend**: Python 3.12
+- **AI Integration**:
+  - OpenAI API
+  - Google Gemini API (via OpenRouter)
+  - Anthropic Claude API (via OpenRouter)
+- **Internationalization**: Custom i18n system
+- **Data Export**: ReportLab (PDF generation)
+
+## 📋 Prerequisites
+
+- Python 3.12 or higher
+- OpenAI API key
+- OpenRouter API key (for Gemini-2.0 and Claude-3.5)
+
+## 🚀 Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/mychatme.git
+cd mychatme
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Set environment variables:
+```bash
+# Create .env file
+OPENAI_API_KEY=your_openai_api_key
+OPENROUTER_API_KEY=your_openrouter_api_key
+```
+
+4. Start the application:
+```bash
+streamlit run main.py
+```
+
+## 💡 Usage
+
+1. **Language Selection**:
+   - Choose English/Japanese from the sidebar
+
+2. **AI Model Selection**:
+   - Choose between GPT-4, Gemini-2.0, and Claude-3.5
+   - Select based on each model's strengths
+
+3. **Prompt Templates**:
+   - Create and save templates
+   - Load saved templates
+   - Edit and delete templates
+
+4. **Chat History Management**:
+   - Export chat content (MD/PDF)
+   - Timezone-aware history management
+
+5. **Theme Customization**:
+   - Light/Dark mode
+   - Color theme changes
+
+## 🔒 Security
+
+- API credentials managed via environment variables
+- Secure session state management
+- Error handling and rate limiting implementation
+
+## 🤝 Contributing
+
+1. Fork this repository
+2. Create a new branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Create a Pull Request
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- [Streamlit](https://streamlit.io/) - Amazing web application framework
+- [OpenAI](https://openai.com/) - GPT-4 model provider
+- [OpenRouter](https://openrouter.ai/) - Unified AI model access
+- [ReportLab](https://www.reportlab.com/) - PDF export functionality
+
+## 📞 Support
+
+If you have any issues or suggestions, please let us know in the GitHub Issues section.

agent_chat_history.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+import os
+import pytz
+from config import Config
+
+def save_agent_chat_history(history):
+    """Save agent chat history to a markdown file in the export directory."""
+    try:
+        # Create export directory if it doesn't exist
+        os.makedirs("export", exist_ok=True)
+
+        # Get current time in the configured timezone
+        tz = pytz.timezone(Config.DEFAULT_TIMEZONE)
+        current_time = datetime.now(tz)
+
+        filename = f"export/agent_chat_{current_time.strftime('%Y%m%d_%H%M%S')}.md"
+
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write("# エージェントチャット履歴\n\n")
+            f.write(f"生成日時: {current_time.strftime('%Y-%m-%d %H:%M:%S %Z')}\n\n")
+
+            for entry in history:
+                if "User:" in entry:
+                    f.write(f"## ユーザー\n{entry.replace('User:', '').strip()}\n\n")
+                elif "Editor:" in entry:
+                    f.write(f"## エージェント\n{entry.replace('Editor:', '').strip()}\n\n")
+
+        return filename
+    except Exception as e:
+        raise Exception(f"エージェントチャット履歴の保存に失敗しました: {str(e)}")
+
+if __name__ == "__main__":
+    # テスト用のチャット履歴
+    history = """
+    User: save_agent_chat_history の使い方を教えてください。
+    Editor: はい、save_agent_chat_historyの使い方を説明します。このツールは会話履歴を保存するために使用します。
+
+    User: 保存先はどこですか？
+    Editor: exportディレクトリに保存されます。ディレクトリが存在しない場合は自動的に作成されます。
+    """
+
+    try:
+        saved_file = save_agent_chat_history(history.split('\n'))
+        print(f"チャット履歴を保存しました: {saved_file}")
+    except Exception as e:
+        print(f"エラー: {str(e)}")

attached_assets/Pasted-class-OpenRouterClient-def-init-self-api-key-self-api-key-api-key-self-1735000678229.txt

@@ -0,0 +1,61 @@
+class OpenRouterClient:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1/chat/completions"
+
+    def create(self, model, messages, response_format=None):
+        try:
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "HTTP-Referer": "https://localhost:5000",
+                "X-Title": "ChatMe Application",
+                "Content-Type": "application/json"
+            }
+
+            data = {
+                "model": model,
+                "messages": messages
+            }
+
+            if response_format:
+                data["response_format"] = response_format
+
+            response = requests.post(
+                self.base_url,
+                headers=headers,
+                json=data  # Use json parameter instead of data for automatic JSON encoding
+            )
+            response.raise_for_status()
+
+            response_data = response.json()
+            if not response_data.get('choices') or not response_data['choices'][0].get('message'):
+                raise ValueError(f"Invalid response format from OpenRouter: {response_data}")
+
+            return response_data['choices'][0]['message']['content']
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"OpenRouter API request error: {str(e)}")
+            return None
+        except (KeyError, ValueError) as e:
+            logger.error(f"OpenRouter API response error: {str(e)}")
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected error in OpenRouter API call: {str(e)}")
+            return None
+
+# Initialize OpenRouter client
+openrouter_client = OpenRouterClient(api_key=os.environ.get("OPENROUTER_API_KEY"))
+
+# Available LLM models
+LLM_MODELS = {
+    "OpenAI": {
+        "name": "OpenAI GPT-4",
+        "model": "gpt-4o",
+        "client": "openai"
+    },
+    "OpenRouter": {
+        "name": "Gemini 2.0 Flash",
+        "model": "google/gemini-2.0-flash-exp:free",
+        "client": "openrouter"
+    }
+}

chat_manager.py

@@ -0,0 +1,234 @@
+from typing import List, Dict, Optional
+from dataclasses import dataclass
+from datetime import datetime
+import json
+from config import Config
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.cidfonts import UnicodeCIDFont
+import os
+import pytz
+
+@dataclass
+class ChatSession:
+    id: str
+    messages: List[Dict[str, str]]
+    system_prompt: str
+    model: str
+    created_at: str
+    context_summary: Optional[str] = None
+    context_messages: List[Dict[str, str]] = None
+
+    def __post_init__(self):
+        if self.context_messages is None:
+            self.context_messages = []
+
+class ChatManager:
+    def __init__(self):
+        self.current_session: ChatSession = self._create_new_session()
+        self.history: List[ChatSession] = []
+        self._setup_pdf_fonts()
+
+    def _setup_pdf_fonts(self):
+        """Set up CID fonts for PDF generation with Japanese support"""
+        try:
+            # Register the Japanese font
+            pdfmetrics.registerFont(UnicodeCIDFont('HeiseiMin-W3'))
+            pdfmetrics.registerFont(UnicodeCIDFont('HeiseiKakuGo-W5'))
+        except Exception as e:
+            print(f"Warning: Could not register PDF fonts: {str(e)}")
+
+    def _format_datetime(self, dt_str: str, timezone: str = None) -> str:
+        """Format datetime string according to the specified timezone"""
+        if not timezone:
+            timezone = Config.DEFAULT_TIMEZONE
+
+        try:
+            dt = datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
+            tz = pytz.timezone(timezone)
+            local_dt = pytz.utc.localize(dt).astimezone(tz)
+            return local_dt.strftime("%Y-%m-%d %H:%M:%S %Z")
+        except Exception as e:
+            print(f"Error formatting datetime: {str(e)}")
+            return dt_str
+
+    def _create_new_session(self, system_prompt: str = "", model: str = "gpt-4o") -> ChatSession:
+        return ChatSession(
+            id=datetime.now().strftime("%Y%m%d_%H%M%S"),
+            messages=[],
+            system_prompt=system_prompt,
+            model=model,
+            created_at=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            context_summary=None,
+            context_messages=[]
+        )
+
+    def new_chat(self, system_prompt: str, model: str) -> None:
+        if self.current_session.messages:
+            self.history.append(self.current_session)
+            if len(self.history) > Config.MAX_HISTORY_CHATS:
+                self.history.pop(0)
+        self.current_session = self._create_new_session(system_prompt, model)
+
+    def add_message(self, role: str, content: str) -> None:
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        self.current_session.messages.append(message)
+        self.current_session.context_messages.append(message)
+
+        # Keep only the most recent context window messages
+        if len(self.current_session.context_messages) > Config.CONTEXT_WINDOW_MESSAGES:
+            self.current_session.context_messages.pop(0)
+
+    def get_messages(self, include_system: bool = True, timezone: str = None) -> List[Dict[str, str]]:
+        messages = []
+        if include_system and self.current_session.system_prompt:
+            messages.append({
+                "role": "system",
+                "content": self.current_session.system_prompt
+            })
+
+        # Add context summary if available
+        if self.current_session.context_summary:
+            messages.append({
+                "role": "system",
+                "content": f"Previous conversation context: {self.current_session.context_summary}"
+            })
+
+        # Add recent context messages with formatted timestamps
+        for msg in self.current_session.context_messages:
+            formatted_msg = msg.copy()
+            if "timestamp" in formatted_msg:
+                formatted_msg["timestamp"] = self._format_datetime(formatted_msg["timestamp"], timezone)
+            messages.append(formatted_msg)
+
+        return messages
+
+    def update_context_summary(self, summary: str) -> None:
+        """Update the conversation context summary."""
+        self.current_session.context_summary = summary
+
+    def load_chat(self, session_id: str) -> bool:
+        for session in self.history:
+            if session.id == session_id:
+                self.current_session = session
+                return True
+        return False
+
+    def clear_current_chat(self) -> None:
+        self.current_session = self._create_new_session(
+            self.current_session.system_prompt,
+            self.current_session.model
+        )
+
+    def export_chat_markdown(self, timezone: str = None) -> str:
+        """Export current chat session as Markdown format."""
+        md_content = []
+
+        # Add header with timezone-aware timestamp
+        created_at = self._format_datetime(self.current_session.created_at, timezone)
+        md_content.append(f"# Chat Session - {created_at}\n")
+        md_content.append(f"Model: {self.current_session.model}\n")
+
+        # Add system prompt if exists
+        if self.current_session.system_prompt:
+            md_content.append("## System Prompt\n")
+            md_content.append(f"{self.current_session.system_prompt}\n")
+
+        # Add context summary if exists
+        if self.current_session.context_summary:
+            md_content.append("## Context Summary\n")
+            md_content.append(f"{self.current_session.context_summary}\n")
+
+        # Add messages with timezone-aware timestamps
+        md_content.append("## Messages\n")
+        for msg in self.current_session.messages:
+            role = msg["role"].title()
+            content = msg["content"].replace("\n", "\n  ")
+            timestamp = self._format_datetime(msg.get("timestamp", ""), timezone)
+            md_content.append(f"### {role} ({timestamp})\n{content}\n")
+
+        return "\n".join(md_content)
+
+    def save_markdown_file(self, timezone: str = None) -> str:
+        """Save current chat session as Markdown file and return the filename."""
+        try:
+            # Create export directory if it doesn't exist
+            os.makedirs("export", exist_ok=True)
+
+            filename = f"export/chat_export_{self.current_session.id}.md"
+            content = self.export_chat_markdown(timezone)
+            with open(filename, "w", encoding="utf-8") as f:
+                f.write(content)
+            return filename
+        except Exception as e:
+            raise Exception(f"Failed to save markdown file: {str(e)}")
+
+    def export_chat_pdf(self, timezone: str = None) -> str:
+        """Export current chat session as PDF format."""
+        try:
+            # Create export directory if it doesn't exist
+            os.makedirs("export", exist_ok=True)
+
+            filename = f"export/chat_export_{self.current_session.id}.pdf"
+            doc = SimpleDocTemplate(filename, pagesize=A4)
+            styles = getSampleStyleSheet()
+
+            # Create custom styles with Japanese font support
+            styles.add(ParagraphStyle(
+                name='JapaneseText',
+                parent=styles['Normal'],
+                fontName='HeiseiMin-W3',
+                fontSize=10,
+                leading=14
+            ))
+            styles.add(ParagraphStyle(
+                name='JapaneseHeading',
+                parent=styles['Heading1'],
+                fontName='HeiseiKakuGo-W5',
+                fontSize=16,
+                leading=20
+            ))
+
+            story = []
+
+            # Add header with timezone-aware timestamp
+            created_at = self._format_datetime(self.current_session.created_at, timezone)
+            story.append(Paragraph(f"Chat Session - {created_at}", styles['JapaneseHeading']))
+            story.append(Paragraph(f"Model: {self.current_session.model}", styles['JapaneseText']))
+            story.append(Spacer(1, 12))
+
+            # Add system prompt if exists
+            if self.current_session.system_prompt:
+                story.append(Paragraph("System Prompt", styles['JapaneseHeading']))
+                story.append(Paragraph(self.current_session.system_prompt, styles['JapaneseText']))
+                story.append(Spacer(1, 12))
+
+            # Add context summary if exists
+            if self.current_session.context_summary:
+                story.append(Paragraph("Context Summary", styles['JapaneseHeading']))
+                story.append(Paragraph(self.current_session.context_summary, styles['JapaneseText']))
+                story.append(Spacer(1, 12))
+
+            # Add messages with timezone-aware timestamps
+            story.append(Paragraph("Messages", styles['JapaneseHeading']))
+            for msg in self.current_session.messages:
+                role = msg["role"].title()
+                content = msg["content"]
+                timestamp = self._format_datetime(msg.get("timestamp", ""), timezone)
+
+                story.append(Paragraph(f"{role} ({timestamp})", styles['JapaneseHeading']))
+                story.append(Paragraph(content, styles['JapaneseText']))
+                story.append(Spacer(1, 12))
+
+            doc.build(story)
+            return filename
+
+        except Exception as e:
+            raise Exception(f"Failed to save PDF file: {str(e)}")

config.py

@@ -0,0 +1,44 @@
+import os
+from dataclasses import dataclass
+import pytz
+
+
+@dataclass
+class Config:
+    # the newest OpenAI model is "gpt-4o" which was released May 13, 2024.
+    OPENAI_MODEL = "gpt-4o"
+    GEMINI_MODEL = "google/gemini-2.0-flash-exp:free"
+    # CLAUDE_MODEL = "anthropic/claude-3-sonnet:free"
+    CLAUDE_MODEL = "anthropic/claude-3.5-sonnet"
+    OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"
+
+    SUPPORTED_LANGUAGES = ["en", "ja"]
+    DEFAULT_LANGUAGE = "ja"  # Changed from "en" to "ja"
+
+    # Timezone settings
+    DEFAULT_TIMEZONE = "Asia/Tokyo"
+    SUPPORTED_TIMEZONES = [
+        "Asia/Tokyo",
+        "America/New_York",
+        "America/Los_Angeles",
+        "Europe/London",
+        "Europe/Paris",
+        "Asia/Shanghai",
+        "Asia/Singapore",
+        "Australia/Sydney",
+        "Pacific/Auckland"
+    ]
+
+    # Chat context settings
+    MAX_HISTORY_CHATS = 10
+    MAX_CONTEXT_LENGTH = 4096  # Maximum token length for context
+    MEMORY_SUMMARY_TOKENS = 150  # Length of conversation summaries
+    CONTEXT_WINDOW_MESSAGES = 10  # Number of messages to keep in immediate context
+
+    @staticmethod
+    def get_openai_key():
+        return os.getenv("OPENAI_API_KEY", "")
+
+    @staticmethod
+    def get_openrouter_key():
+        return os.getenv("OPENROUTER_API_KEY", "")

i18n_utils.py

@@ -0,0 +1,30 @@
+import json
+import os
+from typing import Dict
+from config import Config
+
+class I18nManager:
+    _instance = None
+    _translations: Dict[str, Dict] = {}
+    _current_language = Config.DEFAULT_LANGUAGE
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(I18nManager, cls).__new__(cls)
+            cls._instance._load_translations()
+        return cls._instance
+
+    def _load_translations(self):
+        for lang in Config.SUPPORTED_LANGUAGES:
+            file_path = f"locales/{lang}/translation.json"
+            with open(file_path, "r", encoding="utf-8") as f:
+                self._translations[lang] = json.load(f)
+
+    def set_language(self, language: str):
+        if language in Config.SUPPORTED_LANGUAGES:
+            self._current_language = language
+
+    def get_text(self, key: str) -> str:
+        return self._translations.get(self._current_language, {}).get(
+            key, f"Missing translation: {key}"
+        )

llm_client.py

@@ -0,0 +1,108 @@
+import os
+from typing import List, Dict
+import openai
+from config import Config
+from openrouter_client import OpenRouterClient
+
+class LLMClient:
+    def __init__(self):
+        self.openai_client = None
+        self.openrouter_client = None
+        self.test_mode = False  # For testing error scenarios
+        self.initialize_clients()
+
+    def initialize_clients(self):
+        """Initialize API clients with proper error handling"""
+        try:
+            openai_key = Config.get_openai_key()
+            openrouter_key = Config.get_openrouter_key()
+
+            if openai_key:
+                self.openai_client = openai.OpenAI(api_key=openai_key)
+            if openrouter_key:
+                self.openrouter_client = OpenRouterClient()
+        except Exception as e:
+            print(f"Error initializing API clients: {str(e)}")
+
+    def set_test_mode(self, enabled: bool = True):
+        """Enable or disable test mode for simulating errors"""
+        self.test_mode = enabled
+
+    def chat_openai(self, messages: List[Dict[str, str]]) -> str:
+        """Send chat completion request to OpenAI API"""
+        if not self.openai_client:
+            raise ValueError("OpenAI client not initialized. Please check your API key.")
+
+        if self.test_mode:
+            if messages and "test_error" in messages[-1].get("content", "").lower():
+                error_type = messages[-1]["content"].lower()
+                if "api_key" in error_type:
+                    raise ValueError("Invalid API key")
+                elif "rate_limit" in error_type:
+                    raise Exception("Rate limit exceeded")
+                elif "network" in error_type:
+                    raise Exception("Network connection error")
+
+        try:
+            response = self.openai_client.chat.completions.create(
+                model=Config.OPENAI_MODEL,
+                messages=messages
+            )
+            return response.choices[0].message.content
+        except openai.APIError as e:
+            raise Exception(f"OpenAI API error: {str(e)}")
+
+    def chat_gemini(self, messages: List[Dict[str, str]]) -> str:
+        """Send chat completion request to Gemini via OpenRouter"""
+        if not self.openrouter_client:
+            raise ValueError("OpenRouter client not initialized. Please check your API key.")
+
+        try:
+            return self.openrouter_client.create(
+                messages=messages,
+                model=Config.GEMINI_MODEL
+            )
+        except Exception as e:
+            raise Exception(f"Gemini API error: {str(e)}")
+
+    def chat_claude(self, messages: List[Dict[str, str]]) -> str:
+        """Send chat completion request to Claude via OpenRouter"""
+        if not self.openrouter_client:
+            raise ValueError("OpenRouter client not initialized. Please check your API key.")
+
+        try:
+            return self.openrouter_client.create(
+                messages=messages,
+                model=Config.CLAUDE_MODEL
+            )
+        except Exception as e:
+            raise Exception(f"Claude API error: {str(e)}")
+
+    def generate_context_summary(self, messages: List[Dict[str, str]]) -> str:
+        """Generate a summary of the conversation context."""
+        if not self.openai_client:
+            print("OpenAI client not initialized. Skipping context summary.")
+            return ""
+
+        try:
+            summary_prompt = {
+                "role": "system",
+                "content": (
+                    "Summarize the key points of this conversation in a concise way. "
+                    "Focus on the main topics and important details. "
+                    f"Keep the summary within {Config.MEMORY_SUMMARY_TOKENS} tokens."
+                )
+            }
+
+            # Create a list of messages for summarization
+            summary_messages = [summary_prompt] + messages[-Config.CONTEXT_WINDOW_MESSAGES:]
+
+            response = self.openai_client.chat.completions.create(
+                model=Config.OPENAI_MODEL,
+                messages=summary_messages,
+                max_tokens=Config.MEMORY_SUMMARY_TOKENS
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"Failed to generate context summary: {str(e)}")
+            return ""  # Return empty string if summarization fails

locales/en/translation.json

@@ -0,0 +1,45 @@
+{
+    "app_title": "MyChatMe",
+    "language": "Language",
+    "system_prompt": "System Prompt",
+    "chat_placeholder": "Type your message here...",
+    "send": "Send",
+    "clear_chat": "Clear Chat",
+    "model_selection": "Select Model",
+    "chat_history": "Chat History",
+    "new_chat": "New Chat",
+    "settings": "Settings",
+    "timezone": "Timezone",
+    "api_key_openai": "OpenAI API Key",
+    "api_key_openrouter": "OpenRouter API Key",
+    "save_settings": "Save Settings",
+    "error_missing_key": "Please enter API key",
+    "error_api_call": "Error calling API",
+    "error_model_switch": "Failed to switch to the selected model",
+    "error_model_switch_openai": "Failed to switch to GPT-4. Please check your OpenAI API key.",
+    "error_model_switch_openrouter": "Failed to switch to model. Please check your OpenRouter API key.",
+    "error_rate_limit": "Rate limit exceeded. Please try again later.",
+    "error_network": "Network connection error. Please check your connection.",
+    "default_system_prompt": "You are a helpful assistant. Please provide clear and concise responses.",
+    "export_chat": "Export Chat",
+    "export_format": "Export Format",
+    "export_success": "Chat exported successfully!",
+    "export_error": "Error exporting chat",
+    "export_pdf_error": "Error exporting PDF",
+    "developer_mode": "Developer Mode",
+    "enable_error_test": "Enable Error Test Mode",
+    "error_test_enabled": "Error test mode enabled.\nTo test errors, enter these commands:\n- test_error api_key: API key error\n- test_error rate_limit: Rate limit error\n- test_error network: Network error",
+    "error_test_disabled": "Error test mode disabled.",
+    "theme_mode": "Theme Mode",
+    "prompt_templates": "Prompt Templates",
+    "template_name": "Template Name",
+    "template_content": "Template Content",
+    "template_description": "Description (Optional)",
+    "save_template": "Save Template",
+    "delete_template": "Delete Template",
+    "template_saved": "Template saved successfully!",
+    "template_deleted": "Template deleted successfully!",
+    "template_error": "Error processing template",
+    "select_template": "Select Template",
+    "no_templates": "No templates available"
+}

locales/ja/translation.json

@@ -0,0 +1,45 @@
+{
+    "app_title": "MyChatMe",
+    "language": "言語",
+    "system_prompt": "システムプロンプト",
+    "chat_placeholder": "メッセージを入力してください...",
+    "send": "送信",
+    "clear_chat": "チャットをクリア",
+    "model_selection": "モデルを選択",
+    "chat_history": "チャット履歴",
+    "new_chat": "新規チャット",
+    "settings": "設定",
+    "timezone": "タイムゾーン",
+    "api_key_openai": "OpenAI APIキー",
+    "api_key_openrouter": "OpenRouter APIキー",
+    "save_settings": "設定を保存",
+    "error_missing_key": "APIキーを入力してください",
+    "error_api_call": "APIの呼び出しでエラーが発生しました",
+    "error_model_switch": "モデルの切り替えに失敗しました",
+    "error_model_switch_openai": "GPT-4への切り替えに失敗しました。OpenAI APIキーを確認してください。",
+    "error_model_switch_openrouter": "モデルの切り替えに失敗しました。OpenRouter APIキーを確認してください。",
+    "error_rate_limit": "レート制限を超えました。しばらく待ってから再試行してください。",
+    "error_network": "ネットワーク接続エラーが発生しました。接続を確認してください。",
+    "default_system_prompt": "私は役立つアシスタントです。明確で簡潔な応答を提供します。",
+    "export_chat": "チャットをエクスポート",
+    "export_format": "エクスポート形式",
+    "export_success": "チャットのエクスポートが完了しました！",
+    "export_error": "エクスポート中にエラーが発生しました",
+    "export_pdf_error": "PDFエクスポート中にエラーが発生しました",
+    "developer_mode": "開発者モード",
+    "enable_error_test": "エラーテストモードを有効にする",
+    "error_test_enabled": "エラーテストモードが有効になりました。\nエラーをテストするには以下のコマンドを入力してください：\n- test_error api_key：APIキーエラー\n- test_error rate_limit：レート制限エラー\n- test_error network：ネットワークエラー",
+    "error_test_disabled": "エラーテストモードが無効になりました。",
+    "theme_mode": "テーマ設定",
+    "prompt_templates": "プロンプトテンプレート",
+    "template_name": "テンプレート名",
+    "template_content": "テンプレート内容",
+    "template_description": "説明（任意）",
+    "save_template": "テンプレートを保存",
+    "delete_template": "テンプレートを削除",
+    "template_saved": "テンプレートを保存しました！",
+    "template_deleted": "テンプレートを削除しました！",
+    "template_error": "テンプレート処理中にエラーが発生しました",
+    "select_template": "テンプレートを選択",
+    "no_templates": "テンプレートがありません"
+}

main.py

@@ -0,0 +1,261 @@
+import streamlit as st
+import os
+from chat_manager import ChatManager
+from llm_client import LLMClient
+from i18n_utils import I18nManager
+from ui_components import render_message, render_sidebar, show_notification
+from config import Config
+from prompt_template import PromptTemplateManager
+
+# Page configuration
+st.set_page_config(
+    page_title="MyChatMe",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        "Get Help": None,
+        "Report a bug": None,
+        "About": "MyChatMe - Multilingual AI Chat Application"
+    }
+)
+
+# Initialize session state
+if "chat_manager" not in st.session_state:
+    st.session_state.chat_manager = ChatManager()
+if "llm_client" not in st.session_state:
+    st.session_state.llm_client = LLMClient()
+if "i18n" not in st.session_state:
+    st.session_state.i18n = I18nManager()
+if "sidebar_state" not in st.session_state:
+    st.session_state.sidebar_state = "expanded"
+if "test_mode" not in st.session_state:
+    st.session_state.test_mode = False
+if "template_manager" not in st.session_state:
+    st.session_state.template_manager = PromptTemplateManager()
+
+def render_template_manager(i18n):
+    """プロンプトテンプレート管理セクションを表示"""
+    with st.expander(i18n.get_text("prompt_templates")):
+        # テンプレート一覧表示と選択
+        templates = st.session_state.template_manager.list_templates()
+        if templates:
+            template_names = [f"{t['name']} ({t['created_at']})" for t in templates]
+            selected_template = st.selectbox(
+                i18n.get_text("select_template"),
+                [""] + template_names,
+                key="template_selector"
+            )
+
+            if selected_template:
+                template = templates[template_names.index(selected_template) - 1]
+
+                # 選択したテンプレートの内容をフォームに表示
+                new_template_name = st.text_input(
+                    i18n.get_text("template_name"),
+                    value=template["name"],
+                    key=f"edit_name_{template['id']}"
+                )
+                new_template_content = st.text_area(
+                    i18n.get_text("template_content"),
+                    value=template["content"],
+                    key=f"edit_content_{template['id']}"
+                )
+                new_template_description = st.text_input(
+                    i18n.get_text("template_description"),
+                    value=template.get("description", ""),
+                    key=f"edit_description_{template['id']}"
+                )
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    if st.button(i18n.get_text("delete_template")):
+                        if st.session_state.template_manager.delete_template(template["id"]):
+                            show_notification(i18n.get_text("template_deleted"), "success")
+                            # 削除後にセッション状態をクリア
+                            if "template_selector" in st.session_state:
+                                del st.session_state.template_selector
+                            st.rerun()
+                with col2:
+                    if st.button(i18n.get_text("save_template"), key=f"save_button_{template['id']}"):
+                        try:
+                            if st.session_state.template_manager.update_template(
+                                template["id"],
+                                name=new_template_name,
+                                content=new_template_content,
+                                description=new_template_description
+                            ):
+                                show_notification(i18n.get_text("template_saved"), "success")
+                                # 更新後にセッション状態をクリア
+                                if "template_selector" in st.session_state:
+                                    del st.session_state.template_selector
+                                st.rerun()
+                            else:
+                                show_notification(i18n.get_text("template_error"), "error")
+                        except Exception as e:
+                            show_notification(f"{i18n.get_text('template_error')}: {str(e)}", "error")
+
+        # テンプレートが存在しない場合または新規作成モードの場合
+        if not templates or not selected_template:
+            new_template_name = st.text_input(
+                i18n.get_text("template_name"),
+                key="new_template_name"
+            )
+            new_template_content = st.text_area(
+                i18n.get_text("template_content"),
+                key="new_template_content"
+            )
+            new_template_description = st.text_input(
+                i18n.get_text("template_description"),
+                key="new_template_description"
+            )
+
+            if st.button(i18n.get_text("save_template"), key="save_new_template"):
+                try:
+                    if st.session_state.template_manager.add_template(
+                        new_template_name,
+                        new_template_content,
+                        new_template_description
+                    ):
+                        show_notification(i18n.get_text("template_saved"), "success")
+                        # 保存後にセッション状態をクリア
+                        for key in list(st.session_state.keys()):
+                            if key.startswith("new_template_"):
+                                del st.session_state[key]
+                        st.rerun()
+                    else:
+                        show_notification(i18n.get_text("template_error"), "error")
+                except Exception as e:
+                    show_notification(f"{i18n.get_text('template_error')}: {str(e)}", "error")
+
+def main():
+    i18n = st.session_state.i18n
+    chat_manager = st.session_state.chat_manager
+    llm_client = st.session_state.llm_client
+
+    st.title(i18n.get_text("app_title"))
+
+    # Check API keys
+    if not Config.get_openai_key():
+        show_notification(i18n.get_text("error_missing_key") + " (OpenAI)", "warning")
+    if not Config.get_openrouter_key():
+        show_notification(i18n.get_text("error_missing_key") + " (OpenRouter)", "warning")
+
+    # Sidebar
+    language, model = render_sidebar(i18n, chat_manager)
+
+    # Add test mode toggle in sidebar for development
+    with st.sidebar:
+        st.markdown("---")
+        st.header(i18n.get_text("developer_mode"))
+        test_mode = st.checkbox(i18n.get_text("enable_error_test"), value=st.session_state.test_mode)
+        if test_mode != st.session_state.test_mode:
+            st.session_state.test_mode = test_mode
+            llm_client.set_test_mode(test_mode)
+            if test_mode:
+                show_notification(i18n.get_text("error_test_enabled"), "info")
+            else:
+                show_notification(i18n.get_text("error_test_disabled"), "info")
+
+    # Update language
+    if language == "English" and i18n._current_language != "en":
+        i18n.set_language("en")
+        st.rerun()
+    elif language == "日本語" and i18n._current_language != "ja":
+        i18n.set_language("ja")
+        st.rerun()
+
+    # プロンプトテンプレート管理を表示
+    render_template_manager(i18n)
+
+    # System prompt
+    system_prompt = st.text_area(
+        i18n.get_text("system_prompt"),
+        value=i18n.get_text("default_system_prompt"),
+        key="system_prompt"
+    )
+
+    # Chat history selection
+    if chat_manager.history:
+        selected_chat = st.selectbox(
+            i18n.get_text("chat_history"),
+            ["New Chat"] + [f"Chat {session.created_at}" for session in chat_manager.history]
+        )
+
+        if selected_chat != "New Chat":
+            chat_id = chat_manager.history[
+                [f"Chat {session.created_at}" for session in chat_manager.history].index(selected_chat)
+            ].id
+            chat_manager.load_chat(chat_id)
+
+    # Display chat messages
+    for message in chat_manager.get_messages(include_system=False):
+        render_message(message["role"], message["content"])
+
+    # Chat input
+    if prompt := st.chat_input(i18n.get_text("chat_placeholder")):
+        # Add user message
+        chat_manager.add_message("user", prompt)
+        render_message("user", prompt)
+
+        try:
+            # Get AI response based on selected model
+            messages = chat_manager.get_messages()
+            response = None
+
+            # Model selection logic
+            model_map = {
+                "GPT-4": llm_client.chat_openai,
+                "Gemini-2.0": llm_client.chat_gemini,
+                "Claude-3.5": llm_client.chat_claude
+            }
+
+            if model in model_map:
+                try:
+                    response = model_map[model](messages)
+                except Exception as e:
+                    error_msg = str(e)
+                    if "Rate limit exceeded" in error_msg:
+                        if "provider" in error_msg:
+                            show_notification(f"{i18n.get_text('error_rate_limit')} ({error_msg})", "warning")
+                        else:
+                            show_notification(i18n.get_text("error_rate_limit"), "warning")
+                    elif "API key" in error_msg:
+                        if model == "GPT-4":
+                            show_notification(i18n.get_text("error_model_switch_openai"), "error")
+                        else:
+                            show_notification(i18n.get_text("error_model_switch_openrouter"), "error")
+                    elif "network" in error_msg.lower():
+                        show_notification(i18n.get_text("error_network"), "error")
+                    else:
+                        show_notification(f"{i18n.get_text('error_model_switch')}: {error_msg}", "error")
+                    return
+            else:
+                show_notification(f"Invalid model selection: {model}", "error")
+                return
+
+            if response:
+                # Add AI response
+                chat_manager.add_message("assistant", response)
+                render_message("assistant", response)
+
+                # Generate and update context summary periodically
+                if len(chat_manager.current_session.messages) % 5 == 0:  # Every 5 messages
+                    try:
+                        summary = llm_client.generate_context_summary(chat_manager.current_session.messages)
+                        chat_manager.update_context_summary(summary)
+                    except Exception as e:
+                        print(f"Failed to generate context summary: {str(e)}")
+
+            # Keep sidebar expanded after chat
+            st.session_state.sidebar_state = "expanded"
+        except Exception as e:
+            show_notification(f"{i18n.get_text('error_api_call')}: {str(e)}", "error")
+
+    # Clear chat button
+    if st.button(i18n.get_text("clear_chat")):
+        chat_manager.clear_current_chat()
+        st.rerun()
+
+if __name__ == "__main__":
+    main()

openrouter_client.py

@@ -0,0 +1,98 @@
+import os
+import time
+import requests
+from typing import List, Dict, Optional
+from config import Config
+
+class OpenRouterClient:
+    def __init__(self):
+        self.api_key = Config.get_openrouter_key()
+        if not self.api_key:
+            raise ValueError("OpenRouter API key is not set")
+        self.base_url = Config.OPENROUTER_API_BASE
+        self.max_retries = 3
+        self.retry_delay = 2  # Initial delay in seconds
+
+    def create(self, messages: List[Dict[str, str]], model: str = None, response_format: Optional[Dict] = None) -> str:
+        if not self.api_key:
+            raise ValueError("OpenRouter API key is not set")
+
+        retries = 0
+        last_error = None
+
+        while retries < self.max_retries:
+            try:
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}",
+                    "HTTP-Referer": "https://replit.com",
+                    "X-Title": "MyChatMe",
+                    "Content-Type": "application/json"
+                }
+
+                data = {
+                    "model": model or Config.GEMINI_MODEL,
+                    "messages": messages,
+                    "temperature": 0.7,
+                    "max_tokens": 1000
+                }
+
+                if response_format:
+                    data["response_format"] = response_format
+
+                response = requests.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=data,
+                    timeout=30  # Added timeout
+                )
+
+                if response.status_code == 429:
+                    error_data = response.json()
+                    error_message = error_data.get('error', {}).get('message', 'Rate limit exceeded')
+                    print(f"Rate limit error: {error_message}")
+
+                    # Check if it's a provider-specific rate limit
+                    if 'metadata' in error_data.get('error', {}):
+                        provider = error_data['error']['metadata'].get('provider_name', 'Unknown')
+                        raise Exception(f"Rate limit exceeded for provider: {provider}")
+
+                    wait_time = self.retry_delay * (2 ** retries)
+                    print(f"Rate limit exceeded. Waiting {wait_time} seconds before retry...")
+                    time.sleep(wait_time)
+                    retries += 1
+                    continue
+
+                response.raise_for_status()
+                response_data = response.json()
+
+                if "error" in response_data:
+                    raise ValueError(f"OpenRouter API returned error: {response_data['error']}")
+
+                if not response_data.get('choices'):
+                    raise ValueError("No choices in OpenRouter API response")
+
+                if not response_data['choices'][0].get('message'):
+                    raise ValueError("No message in OpenRouter API response choice")
+
+                return response_data['choices'][0]['message']['content']
+
+            except requests.exceptions.RequestException as e:
+                print(f"OpenRouter Request Error: {str(e)}")
+                last_error = e
+                retries += 1
+                if retries < self.max_retries:
+                    time.sleep(self.retry_delay * (2 ** retries))
+            except ValueError as e:
+                print(f"OpenRouter Value Error: {str(e)}")
+                last_error = e
+                break
+            except Exception as e:
+                print(f"OpenRouter Unexpected Error: {str(e)}")
+                last_error = e
+                break
+
+        # If all retries failed or other error occurred
+        error_msg = str(last_error) if last_error else "Maximum retries exceeded"
+        if "Rate limit exceeded" in error_msg:
+            raise Exception(f"OpenRouter rate limit exceeded. Please try again later or switch to a different model.")
+        raise Exception(f"OpenRouter API error: {error_msg}")

prompt_template.py

@@ -0,0 +1,92 @@
+import json
+import os
+from typing import Dict, List
+from datetime import datetime
+
+class PromptTemplateManager:
+    def __init__(self):
+        self.templates_dir = "templates"
+        self.ensure_template_directory()
+        self._templates: Dict[str, Dict] = {}
+        self.load_templates()
+
+    def ensure_template_directory(self):
+        """テンプレートディレクトリが存在しない場合は作成"""
+        if not os.path.exists(self.templates_dir):
+            os.makedirs(self.templates_dir)
+
+    def load_templates(self):
+        """保存されているテンプレートを読み込む"""
+        template_file = os.path.join(self.templates_dir, "templates.json")
+        if os.path.exists(template_file):
+            try:
+                with open(template_file, "r", encoding="utf-8") as f:
+                    self._templates = json.load(f)
+            except Exception as e:
+                print(f"テンプレート読み込みエラー: {str(e)}")
+                self._templates = {}
+
+    def save_templates(self):
+        """テンプレートをファイルに保存"""
+        template_file = os.path.join(self.templates_dir, "templates.json")
+        try:
+            with open(template_file, "w", encoding="utf-8") as f:
+                json.dump(self._templates, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            raise Exception(f"テンプレート保存エラー: {str(e)}")
+
+    def add_template(self, name: str, content: str, description: str = "") -> bool:
+        """新しいテンプレートを追加"""
+        if not name or not content:
+            return False
+
+        template_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self._templates[template_id] = {
+            "name": name,
+            "content": content,
+            "description": description,
+            "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        self.save_templates()
+        return True
+
+    def get_template(self, template_id: str) -> Dict:
+        """指定されたIDのテンプレートを取得"""
+        return self._templates.get(template_id, {})
+
+    def list_templates(self) -> List[Dict]:
+        """全てのテンプレートをリスト形式で取得"""
+        return [
+            {"id": k, **v}
+            for k, v in self._templates.items()
+        ]
+
+    def delete_template(self, template_id: str) -> bool:
+        """テンプレートを削除"""
+        if template_id in self._templates:
+            del self._templates[template_id]
+            self.save_templates()
+            return True
+        return False
+
+    def update_template(
+        self,
+        template_id: str,
+        name: str | None = None,
+        content: str | None = None,
+        description: str | None = None
+    ) -> bool:
+        """テンプレートを更新"""
+        if template_id not in self._templates:
+            return False
+
+        template = self._templates[template_id]
+        if name is not None:
+            template["name"] = name
+        if content is not None:
+            template["content"] = content
+        if description is not None:
+            template["description"] = description
+
+        self.save_templates()
+        return True

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "repl-nix-ailanguagecompanion"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "openai>=1.58.1",
+    "pytz>=2024.2",
+    "reportlab>=4.2.5",
+    "requests>=2.32.3",
+    "streamlit>=1.41.1",
+]

replit.nix

@@ -0,0 +1,6 @@
+{pkgs}: {
+  deps = [
+    pkgs.glibcLocales
+    pkgs.freetype
+  ];
+}

save_chat_history.py

@@ -0,0 +1,14 @@
+from chat_manager import ChatManager
+from datetime import datetime
+
+def save_chat_history():
+    chat_manager = ChatManager()
+    filename = f"chat_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+    
+    try:
+        content = chat_manager.export_chat_markdown()
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(content)
+        return filename
+    except Exception as e:
+        raise Exception(f"Failed to save chat history: {str(e)}")

templates/templates.json

@@ -0,0 +1,14 @@
+{
+  "20241224_054200": {
+    "name": "テンプレ1",
+    "content": "こんにちは。あなたはインターネットに精通している技術者です。",
+    "description": "こんにちは。あなたはインターネットに精通している技術者です。",
+    "created_at": "2024-12-24 05:42:00"
+  },
+  "20241224_054237": {
+    "name": "テンプレ2",
+    "content": "あなたはインターネットに精通している技術者です。",
+    "description": "あなたはインターネットに精通している技術者です。",
+    "created_at": "2024-12-24 05:42:37"
+  }
+}

ui_components.py

@@ -0,0 +1,90 @@
+import streamlit as st
+from datetime import datetime
+import pytz
+from config import Config
+
+def render_message(role: str, content: str, timezone: str = Config.DEFAULT_TIMEZONE):
+    """タイムゾーンを考慮してメッセージを表示"""
+    if role == "assistant":
+        with st.chat_message(role, avatar="🤖"):
+            st.write(content)
+    elif role == "user":
+        with st.chat_message(role, avatar="👤"):
+            st.write(content)
+    else:
+        with st.chat_message(role):
+            st.write(content)
+
+def show_notification(message: str, type: str = "info", duration: int = 3):
+    """Show an elegant notification toast."""
+    if type == "error":
+        st.error(message, icon="🚨")
+    elif type == "success":
+        st.success(message, icon="✅")
+    elif type == "warning":
+        st.warning(message, icon="⚠️")
+    else:
+        st.info(message, icon="ℹ️")
+
+def render_sidebar(i18n, chat_manager):
+    # Create a persistent sidebar container
+    sidebar = st.sidebar
+
+    # Ensure sidebar is visible
+    if "sidebar_visibility" not in st.session_state:
+        st.session_state.sidebar_visibility = True
+
+    # Initialize timezone in session state if not exists
+    if "timezone" not in st.session_state:
+        st.session_state.timezone = Config.DEFAULT_TIMEZONE
+
+    with sidebar:
+        st.title(i18n.get_text("settings"))
+
+        # Language selection - デフォルトを日本語に設定
+        language = st.selectbox(
+            i18n.get_text("language"),
+            ["English", "日本語"],
+            index=1,
+            key="language_selector"
+        )
+
+        # Model selection - デフォルトをGemini-2.0に設定
+        model = st.selectbox(
+            i18n.get_text("model_selection"),
+            ["GPT-4", "Gemini-2.0", "Claude-3.5"],
+            index=1,
+            key="model_selection"
+        )
+
+        # Timezone selection
+        timezone = st.selectbox(
+            i18n.get_text("timezone"),
+            Config.SUPPORTED_TIMEZONES,
+            index=Config.SUPPORTED_TIMEZONES.index(Config.DEFAULT_TIMEZONE),
+            key="timezone_selector"
+        )
+        st.session_state.timezone = timezone
+
+        st.markdown("---")
+
+        # Export section
+        export_format = st.selectbox(
+            i18n.get_text("export_format"),
+            ["Markdown", "PDF"],
+            key="export_format"
+        )
+
+        if st.button(i18n.get_text("export_chat"), key="export_button"):
+            try:
+                timezone = st.session_state.get("timezone", Config.DEFAULT_TIMEZONE)
+                if export_format == "Markdown":
+                    filename = chat_manager.save_markdown_file(timezone=timezone)
+                    show_notification(f"{i18n.get_text('export_success')} ({filename})", "success")
+                else:
+                    filename = chat_manager.export_chat_pdf(timezone=timezone)
+                    show_notification(f"{i18n.get_text('export_success')} ({filename})", "success")
+            except Exception as e:
+                show_notification(f"{i18n.get_text('export_error')}: {str(e)}", "error")
+
+        return language, model