chatatp-cli 1.0.0__tar.gz

chatatp_cli-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: chatatp-cli
+Version: 1.0.0
+Summary: ChatATP CLI - Terminal Interface for ChatATP API
+Author-email: ChatATP Team <support@chatatp.com>
+Project-URL: Homepage, https://chat-atp.com
+Project-URL: Documentation, https://docs.chat-atp.com
+Project-URL: Repository, https://github.com/sam-14uel/ChatATP-Python-Cli
+Project-URL: Issues, https://github.com/sam-14uel/ChatATP-Python-Cli/issues
+Requires-Dist: requests
+Requires-Dist: click
+Requires-Dist: rich
+Requires-Dist: pyyaml
+Requires-Dist: python-dotenv

chatatp_cli-1.0.0/README.md

@@ -0,0 +1,341 @@
+# ChatATP CLI
+
+A powerful terminal interface for the ChatATP API, built with Python. Interact with ChatATP's AI models, manage chatrooms, toolkits, integrations, and more directly from your command line.
+
+## ✨ What's New (v1.0.0)
+
+### 🚀 Agentic Loop Support
+- **Interactive Conversations**: Back-and-forth chat with persistent context
+- **Real-time Streaming**: Responses appear as they're generated with tool call visualization
+- **Auto-enter Chatrooms**: `chat new` now creates AND enters chat automatically
+- **In-chat Commands**: Rich command system during conversations (`/exit`, `/help`, `/clear`, `/history`)
+
+### 🔄 Chat Evolution
+- **Before**: One-shot messages that exit immediately
+- **Now**: Persistent interactive sessions with agentic conversations
+- **Streaming**: Tool calls, thinking blocks, and responses all visualized in real-time
+
+## Features
+
+- **Account Management**: View your ChatATP account information
+- **Model Management**: List and manage AI models
+- **Interactive Chat**: Agentic loop support with back-and-forth conversations
+- **Toolkit Management**: Browse and manage your toolkits and collections
+- **Integration Management**: Manage OAuth and custom integrations
+- **AI Configuration**: Configure AI providers, models, and settings
+- **Media Management**: Browse and manage uploaded media files
+- **Store Access**: Browse featured and popular toolkits
+- **MCP Support**: Manage MCP servers and connections
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install chatatp-cli
+```
+
+### From Source
+
+1. Clone or download this repository
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Make the script executable (optional):
+   ```bash
+   chmod +x main.py
+   ```
+
+## Configuration
+
+Before using the CLI, you need to configure your API token:
+
+```bash
+python main.py config set-token YOUR_API_TOKEN_HERE
+```
+
+You can also configure other settings:
+
+```bash
+# Set custom API base URL (default: https://api.chat-atp.com)
+python main.py config set-base-url https://your-custom-api-url.com
+
+# Set default model
+python main.py config set-default-model gpt-oss-120b
+
+# View current configuration
+python main.py config show
+```
+
+## Usage
+
+### Getting Help
+
+```bash
+python main.py --help
+```
+
+### Account Information
+
+```bash
+python main.py account
+```
+
+### Models
+
+```bash
+# List available models
+python main.py models
+
+# List models for a specific provider
+python main.py ai provider-models PROVIDER_ID
+```
+
+## 🎯 Interactive Chat System
+
+The ChatATP CLI now supports **true agentic conversations** with persistent context, just like chatting with ChatGPT or Claude!
+
+### New Interactive Commands
+
+#### **Start New Interactive Chat**
+```bash
+python main.py chat new "Tell me about machine learning"
+```
+- Creates a new chatroom
+- Automatically enters interactive mode
+- Sends your initial message
+- Starts back-and-forth conversation loop
+
+#### **Enter Existing Chatroom**
+```bash
+python main.py chat converse ROOM_ID
+```
+- Enter any existing chatroom for interactive chat
+- Continue conversations where you left off
+- Same interactive experience as new chats
+
+### In-Chat Commands
+
+While in interactive mode, you have access to these commands:
+
+- **`/exit`**, **`/quit`**, **`/q`** - Exit the current chat session
+- **`/help`**, **`/h`** - Show available commands
+- **`/clear`** - Clear the screen and show current chat info
+- **`/history`** - Show recent messages from chat history
+
+### Interactive Chat Flow
+
+```
+$ python main.py chat new "Hello, let's discuss AI"
+
+Chatroom created: abc123
+Entered chatroom: abc123
+Type your message or '/exit' to quit, '/help' for commands
+
+You: Hello, let's discuss AI
+
+ChatATP ·
+
+Hello! I'd be happy to discuss AI with you. What specific aspects of artificial intelligence are you interested in? Whether it's machine learning algorithms, current trends, ethical considerations, or practical applications, I'm here to help!
+
+─────────────────────────────────
+You: Tell me about neural networks
+
+ChatATP ·
+
+Neural networks are fascinating! Let me explain them step by step:
+
+A neural network is a computational model inspired by the human brain's neural structure. It consists of interconnected nodes (neurons) organized in layers...
+
+─────────────────────────────────
+You: /help
+
+Available commands:
+  /exit, /quit, /q  - Exit the chat
+  /help, /h         - Show this help
+  /clear             - Clear the screen
+  /history           - Show chat history
+
+You: /exit
+Exiting chat...
+```
+
+### Legacy Commands (Still Supported)
+
+#### **One-shot Message Sending**
+```bash
+# Send single message (legacy - exits immediately)
+python main.py chat send ROOM_ID "Your message here"
+
+# Send with specific model and toolkits
+python main.py chat send ROOM_ID "Analyze this data" --model gpt-oss-120b --toolkits TOOLKIT_ID1 TOOLKIT_ID2
+
+# Debug mode to see raw chunks
+python main.py chat send ROOM_ID "Debug message" --debug
+```
+
+#### **Chatroom Management**
+```bash
+# List your chatrooms
+python main.py chat rooms
+
+# Show details of a specific chatroom
+python main.py chat show ROOM_ID
+```
+
+### Toolkits
+
+```bash
+# List your toolkits
+python main.py toolkits
+
+# Browse featured toolkits
+python main.py store featured
+
+# Browse popular toolkits
+python main.py store popular
+```
+
+### Integrations
+
+```bash
+# List OAuth integrations
+python main.py integrations list
+
+# List custom integrations
+python main.py integrations custom
+```
+
+### AI Management
+
+```bash
+# List AI providers
+python main.py ai providers
+
+# List AI configurations
+python main.py ai configs
+
+# Show AI settings
+python main.py ai settings
+```
+
+### Media
+
+```bash
+# List your media files
+python main.py media
+
+# Search media
+python main.py media --search "document name"
+
+# Filter by type
+python main.py media --type image
+
+# Pagination
+python main.py media --page 2 --page-size 20
+```
+
+### Pricing
+
+```bash
+# View pricing plans
+python main.py pricing
+```
+
+## Authentication
+
+All commands require authentication. Make sure you've set your API token using:
+
+```bash
+python main.py config set-token YOUR_TOKEN
+```
+
+The token will be stored securely in your home directory under `~/.chatatp/config.yaml`.
+
+## Advanced Features
+
+### Real-time Streaming with Tool Visualization
+
+The CLI now provides rich visualization of:
+
+- **Tool Calls**: See when tools are being executed with timing
+- **Thinking Blocks**: Visual indicators when AI is reasoning
+- **Progress Indicators**: Spinners and status updates during processing
+- **Error Handling**: Graceful handling of network issues and API errors
+
+### Example with Tool Calls
+
+```
+You: Search for information about OpenClaw AI
+
+ChatATP ·
+
+I need to search for information about OpenClaw AI. Let me use the search tool.
+
+  ┌ search_web · web_search_toolkit
+  └ done 0.34s
+
+Based on my search, OpenClaw is...
+```
+
+### Interactive vs One-shot Mode Comparison
+
+| Feature | Interactive Mode (`chat new/converse`) | One-shot Mode (`chat send`) |
+|---------|----------------------------------------|----------------------------|
+| **Persistence** | ✅ Back-and-forth conversation | ❌ Single message only |
+| **Context** | ✅ Full conversation history | ❌ No context retention |
+| **Commands** | ✅ Rich in-chat commands | ❌ None |
+| **Tool Visualization** | ✅ Real-time with progress | ✅ Basic streaming |
+| **Exit Behavior** | Manual exit with `/exit` | Auto-exit after response |
+| **Use Case** | Deep conversations, exploration | Quick questions, automation |
+
+## Error Handling
+
+The CLI provides clear error messages for common issues:
+- Missing API token
+- Invalid room IDs
+- Network errors
+- Authentication failures
+- Streaming interruptions
+
+## Dependencies
+
+- requests: HTTP client
+- click: Command line interface
+- rich: Beautiful terminal output with progress indicators
+- pyyaml: Configuration file handling
+- python-dotenv: Environment variable support
+
+## Migration Guide
+
+### From v1.x to v2.0
+
+**Old workflow:**
+```bash
+# Create room
+python main.py chat new "Hello"
+# Copy room ID
+# Send messages one by one
+python main.py chat send ROOM_ID "Follow up question"
+python main.py chat send ROOM_ID "Another question"
+```
+
+**New workflow:**
+```bash
+# Single command starts interactive session
+python main.py chat new "Hello, let's have a conversation"
+# Now chat back and forth naturally!
+# Type /exit when done
+```
+
+**Legacy commands still work:** All v1.x commands (`chat send`, etc.) remain fully functional for scripts and automation.
+
+## Contributing
+
+Feel free to submit issues and pull requests to improve the ChatATP CLI.
+
+## License
+
+This project is licensed under the MIT License.

chatatp_cli-1.0.0/chatatp_cli/api_client.py

@@ -0,0 +1,183 @@
+import requests
+from typing import Dict, List, Optional, Any
+import json
+from config import Config
+
+class ChatATPAPI:
+    def __init__(self, config: Config):
+        self.config = config
+        self.session = requests.Session()
+        self.session.headers.update(self.config.get_headers())
+
+    def _get(self, endpoint: str, params: Optional[Dict] = None) -> Dict:
+        """Make GET request"""
+        url = f"{self.config.api_base_url}{endpoint}"
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    def _post(self, endpoint: str, data: Optional[Dict] = None) -> Dict:
+        """Make POST request"""
+        url = f"{self.config.api_base_url}{endpoint}"
+        response = self.session.post(url, json=data)
+        response.raise_for_status()
+        return response.json()
+
+    def _patch(self, endpoint: str, data: Optional[Dict] = None) -> Dict:
+        """Make PATCH request"""
+        url = f"{self.config.api_base_url}{endpoint}"
+        response = self.session.patch(url, json=data)
+        response.raise_for_status()
+        return response.json()
+
+    def _delete(self, endpoint: str) -> Dict:
+        """Make DELETE request"""
+        url = f"{self.config.api_base_url}{endpoint}"
+        response = self.session.delete(url)
+        response.raise_for_status()
+        return response.json() if response.content else {}
+
+    # Account endpoints
+    def get_account(self) -> Dict:
+        """Get user account information"""
+        return self._get('/api/v1/account/')
+
+    # Models endpoints
+    def list_models(self) -> List[Dict]:
+        """List available models"""
+        return self._get('/api/v1/list-models/')
+
+    # Collections/Toolkits endpoints
+    def list_collections(self) -> Dict:
+        """List toolkits collections"""
+        return self._get('/api/v1/collections/toolkits/')
+
+    # MCP endpoints
+    def list_mcp_connections(self) -> Dict:
+        """List MCP connections"""
+        return self._get('/api/v1/mcp/connections/')
+
+    def list_mcp_servers(self) -> Dict:
+        """List MCP servers"""
+        return self._get('/api/v1/mcp/servers/')
+
+    # Chat endpoints
+    def list_chatrooms(self) -> Dict:
+        """List chatrooms"""
+        return self._get('/api/v1/chatrooms/')
+
+    def get_chatroom(self, room_id: str) -> Dict:
+        """Get chatroom details"""
+        return self._get(f'/api/v1/chats/{room_id}/')
+
+    def create_chatroom(self, message: str, model: str = None, toolkit_ids: List[str] = None,
+                       mcp_server_connection_ids: List[str] = None) -> Dict:
+        """Create new chatroom"""
+        data = {'message': message}
+        if model:
+            data['model'] = model
+        if toolkit_ids:
+            data['toolkit_ids'] = toolkit_ids
+        if mcp_server_connection_ids:
+            data['mcp_server_connection_ids'] = mcp_server_connection_ids
+        return self._post('/api/v1/chats/new/', data)
+
+    def send_chat_message_stream(self, room_id: str, message: str, model: str = None,
+                               toolkit_ids: List[str] = None, mcp_server_connection_ids: List[str] = None,
+                               attachments: List = None):
+        """Send chat message and yield streaming response chunks"""
+        url = f"{self.config.api_base_url}/api/v1/chats/{room_id}/completions/stream/"
+        data = {
+            'message_type': 'chat_message',
+            'message': message,
+            'model': model or self.config.default_model,
+            'toolkit_ids': toolkit_ids or [],
+            'mcp_server_connection_ids': mcp_server_connection_ids or [],
+            'attachments': attachments or []
+        }
+
+        with self.session.post(url, json=data, stream=True) as response:
+            response.raise_for_status()
+            buffer = ""
+
+            for line in response.iter_lines():
+                if not line:
+                    continue
+
+                line = line.decode('utf-8')
+
+                # Handle SSE format: "data: {...}"
+                if line.startswith('data: '):
+                    line = line[6:]
+
+                # Skip SSE comments or keep-alive
+                if line.startswith(':'):
+                    continue
+
+                buffer += line
+
+                # Try to parse whatever is in the buffer
+                while buffer:
+                    buffer = buffer.strip()
+                    if not buffer:
+                        break
+                    try:
+                        chunk, idx = json.JSONDecoder().raw_decode(buffer)
+                        yield chunk
+                        buffer = buffer[idx:].strip()
+                    except json.JSONDecodeError:
+                        # Incomplete JSON, wait for more data
+                        break
+
+    # Media endpoints
+    def list_media(self, page: int = 1, page_size: int = 12, media_type: str = None, search: str = None) -> Dict:
+        """List user media"""
+        params = {'page': page, 'page_size': page_size}
+        if media_type:
+            params['type'] = media_type
+        if search:
+            params['search'] = search
+        return self._get('/api/v1/media/', params)
+
+    # Integrations endpoints
+    def list_integrations(self) -> Dict:
+        """List integrated accounts"""
+        return self._get('/api/v1/integrations/')
+
+    def list_custom_integrations(self) -> Dict:
+        """List custom integrated accounts"""
+        return self._get('/api/v1/integrations/custom/')
+
+    def list_ai_configs(self) -> List[Dict]:
+        """List AI provider configurations"""
+        return self._get('/api/v1/integrations/ai/providers/configs/')
+
+    def list_ai_providers(self) -> List[Dict]:
+        """List AI providers"""
+        return self._get('/api/v1/integrations/ai/providers/')
+
+    def list_provider_models(self, provider_id: str) -> List[Dict]:
+        """List models for a provider"""
+        return self._get('/api/v1/list-provider-models/', {'provider': provider_id})
+
+    def get_ai_settings(self) -> Dict:
+        """Get AI settings"""
+        return self._get('/api/v1/integrations/ai/settings/')
+
+    # Store endpoints
+    def list_featured_toolkits(self) -> Dict:
+        """List featured toolkits"""
+        return self._get('/api/v1/store/toolkits/featured/')
+
+    def list_popular_toolkits(self) -> Dict:
+        """List popular toolkits"""
+        return self._get('/api/v1/store/toolkits/popular/')
+
+    def list_recommended_toolkits(self) -> Dict:
+        """List recommended toolkits"""
+        return self._get('/api/v1/store/toolkits/for_you/')
+
+    # Pricing endpoints
+    def get_pricing(self) -> List[Dict]:
+        """Get pricing information"""
+        return self._get('/api/v1/payments/pricing/')

chatatp_cli-1.0.0/chatatp_cli/config.py

@@ -0,0 +1,68 @@
+import os
+from typing import Optional
+import yaml
+from pathlib import Path
+
+class Config:
+    def __init__(self, config_file: str = None):
+        self.config_file = config_file or os.path.join(Path.home(), '.chatatp', 'config.yaml')
+        self._config = {}
+        self.load_config()
+
+    def load_config(self):
+        """Load configuration from file"""
+        try:
+            if os.path.exists(self.config_file):
+                with open(self.config_file, 'r') as f:
+                    self._config = yaml.safe_load(f) or {}
+            else:
+                self._config = {}
+        except Exception as e:
+            print(f"Warning: Could not load config file: {e}")
+            self._config = {}
+
+    def save_config(self):
+        """Save configuration to file"""
+        try:
+            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+            with open(self.config_file, 'w') as f:
+                yaml.dump(self._config, f, default_flow_style=False)
+        except Exception as e:
+            print(f"Error saving config: {e}")
+
+    @property
+    def api_base_url(self) -> str:
+        return self._config.get('api_base_url', 'https://api.chat-atp.com')
+
+    @api_base_url.setter
+    def api_base_url(self, value: str):
+        self._config['api_base_url'] = value
+        self.save_config()
+
+    @property
+    def api_token(self) -> Optional[str]:
+        return self._config.get('api_token')
+
+    @api_token.setter
+    def api_token(self, value: str):
+        self._config['api_token'] = value
+        self.save_config()
+
+    @property
+    def default_model(self) -> str:
+        return self._config.get('default_model', 'gpt-oss-120b')
+
+    @default_model.setter
+    def default_model(self, value: str):
+        self._config['default_model'] = value
+        self.save_config()
+
+    def get_headers(self) -> dict:
+        """Get headers for API requests"""
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+        if self.api_token:
+            headers['Authorization'] = f'Token {self.api_token}'
+        return headers