commandchat 0.0.12__tar.gz → 0.0.13__tar.gz

{commandchat-0.0.12 → commandchat-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandchat
-Version: 0.0.12
+Version: 0.0.13
 Summary: use command to chat with openai models
 Home-page: https://github.com/
 Author: xoto
@@ -17,7 +17,10 @@ Requires-Dist: click
 Requires-Dist: Image
 Requires-Dist: openai
 Requires-Dist: prompt_toolkit
+Requires-Dist: pyperclip
 Requires-Dist: rich
+Requires-Dist: requests
+Requires-Dist: questionary
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

{commandchat-0.0.12 → commandchat-0.0.13}/commandchat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandchat
-Version: 0.0.12
+Version: 0.0.13
 Summary: use command to chat with openai models
 Home-page: https://github.com/
 Author: xoto
@@ -17,7 +17,10 @@ Requires-Dist: click
 Requires-Dist: Image
 Requires-Dist: openai
 Requires-Dist: prompt_toolkit
+Requires-Dist: pyperclip
 Requires-Dist: rich
+Requires-Dist: requests
+Requires-Dist: questionary
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

{commandchat-0.0.12 → commandchat-0.0.13}/commandchat.egg-info/requires.txt

@@ -2,4 +2,7 @@ click
 Image
 openai
 prompt_toolkit
+pyperclip
 rich
+requests
+questionary

commandchat-0.0.13/occ/CommandChat.py

@@ -0,0 +1,407 @@
+import asyncio
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import AsyncGenerator, Optional
+from dataclasses import dataclass
+
+from openai import AzureOpenAI
+from openai import OpenAI
+from openai.types.chat.chat_completion_chunk import Choice
+from prompt_toolkit import print_formatted_text, HTML, Application
+from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
+from prompt_toolkit.layout import Layout, HSplit
+from prompt_toolkit.widgets import TextArea
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+
+from occ.commons.config import get_env
+
+
+@dataclass
+class StreamChunk:
+    """Unified streaming chunk for both chat.completions and responses API"""
+    content: Optional[str] = None
+    role: Optional[str] = None
+    finish_reason: Optional[str] = None
+    event_type: Optional[str] = None
+
+
+DEFAULT_CHAT_LOG_ID = "chat-1"
+DEFAULT_PROFILE = "default"
+USER_COLOR = "ansiyellow"
+ASSISTANT_COLOR = "ansicyan"
+TYPING_DELAY = 0.01  # 打字速度（秒/字符）
+SEPARATOR = "─" * 30
+
+
+def get_home_path():
+    homedir = os.environ.get('HOME', None)
+    if os.name == 'nt':
+        homedir = os.path.expanduser('~')
+    return homedir
+
+
+clip = PyperclipClipboard()
+console = Console()
+
+def print_formatted(content: str, live: Live):
+    md = Markdown(content)
+    live.update(md)
+    sys.stdout.flush()
+
+
+class CommandChat:
+    partial_text = []
+    role = None
+
+    def __init__(self, profile=None, chat_log_id=None, model=None):
+        now = time.strftime("%Y%m%d", time.localtime())
+        self.profile = profile or DEFAULT_PROFILE
+        self.api_server_type = get_env(self.profile, "api_server_type")
+        
+        if not self.api_server_type:
+            raise ValueError(f"Profile '{self.profile}' is not configured. Please run 'occ configure -p {self.profile}' first.")
+        
+        self.limit_history = int(get_env(self.profile, "limit_history") or 4)
+        self.chat_log_id = chat_log_id or DEFAULT_CHAT_LOG_ID
+        self.folder_path = os.path.join(get_home_path(), ".occ", self.profile)
+        self.image_folder_path = os.path.join(self.folder_path, "images")
+        self.file_name = os.path.join(self.folder_path, f"{self.chat_log_id}.log")
+        os.makedirs(self.folder_path, exist_ok=True)
+        os.makedirs(self.image_folder_path, exist_ok=True)
+        self.model = model
+        self.current_model_config = None
+        
+        if not os.path.exists(self.file_name):
+            open(self.file_name, 'w').close()
+        self.history_path = Path(self.folder_path, self.chat_log_id) / f"md_history_{now}.md"
+        # Load messages and filter out invalid ones (with null role)
+        self.messages = []
+        for line in open(self.file_name):
+            line = line.strip()
+            if line:
+                try:
+                    msg = json.loads(line)
+                    # Ensure role is valid
+                    if msg.get('role') in ['system', 'assistant', 'user', 'function', 'tool', 'developer']:
+                        self.messages.append(msg)
+                except json.JSONDecodeError:
+                    continue
+        
+        # Initialize client based on API server type
+        if self.api_server_type == "azure-openai":
+            # For Azure OpenAI, we'll initialize client per model in chat method
+            self.client = None
+        elif self.api_server_type == "openai":
+            self.api_key = get_env(self.profile, "api_key")
+            self.api_base = get_env(self.profile, "api_base_url")
+            
+            if not self.api_key:
+                raise ValueError(f"API key not configured for profile '{self.profile}'. Please run 'occ configure -p {self.profile}' first.")
+            
+            os.environ.setdefault("OPENAI_API_KEY", self.api_key)
+            os.environ.setdefault("OPENAI_BASE_URL", self.api_base)
+            self.client = OpenAI()
+        else:
+            # Fallback for legacy "azure" type
+            self.api_key = get_env(self.profile, "api_key")
+            self.api_base = get_env(self.profile, "api_base_url")
+            
+            if not self.api_key:
+                raise ValueError(f"API key not configured for profile '{self.profile}'. Please run 'occ configure -p {self.profile}' first.")
+            
+            os.environ.setdefault("OPENAI_API_KEY", self.api_key)
+            os.environ.setdefault("OPENAI_BASE_URL", self.api_base)
+            if "azure" == self.api_server_type:
+                self.client = AzureOpenAI(api_key=self.api_key,
+                                          api_version=get_env(self.profile, "api_version"),
+                                          azure_endpoint=self.api_base)
+            else:
+                self.client = OpenAI()
+    
+    def _get_azure_client(self, model):
+        """Get Azure OpenAI client for a specific model"""
+        from occ.commons.config import get_model_config
+        
+        model_config = get_model_config(self.profile, model)
+        if not model_config:
+            raise ValueError(f"Model '{model}' not found in profile '{self.profile}'")
+        
+        self.current_model_config = model_config
+        return AzureOpenAI(
+            api_key=model_config['api_key'],
+            api_version=model_config['api_version'],
+            azure_endpoint=model_config['api_base_url']
+        )
+    
+    def _is_completions_model(self, model):
+        """Check if model uses completions API instead of chat completions API"""
+        # Azure OpenAI behavior is different from standard OpenAI
+        # For Azure, most models (including codex) use chat completions API
+        if self.api_server_type in ["azure-openai", "azure"]:
+            # Only specific instruct models use completions API in Azure
+            azure_completions_models = [
+                'gpt-35-turbo-instruct',
+                'text-davinci-003',
+                'text-davinci-002',
+            ]
+            return model in azure_completions_models
+        
+        # For standard OpenAI
+        completions_models = [
+            'gpt-35-turbo-instruct',
+            'text-davinci-003',
+            'text-davinci-002',
+            'text-curie-001',
+            'text-babbage-001',
+            'text-ada-001',
+        ]
+        
+        # Check exact match
+        if model in completions_models:
+            return True
+        
+        # Check if model contains 'instruct' or 'davinci' (but not codex for standard OpenAI)
+        # Note: Codex models behavior varies, so we only check by keyword for OpenAI
+        model_lower = model.lower()
+        if any(keyword in model_lower for keyword in ['instruct', 'davinci']):
+            return True
+        
+        return False
+
+    def image_create(self, description, size, num):
+        raise NotImplementedError
+
+    def chat(self, message, model):
+        # Initialize Azure client if needed
+        if self.api_server_type == "azure-openai":
+            self.client = self._get_azure_client(model)
+        
+        print_formatted_text(HTML(f"<{ASSISTANT_COLOR}>🤖 Assistant: </{ASSISTANT_COLOR}>"))
+        
+        # Check if model requires completions API instead of chat completions
+        # Models like gpt-35-turbo-instruct, text-davinci-003, codex variants use completions API
+        if self._is_completions_model(model):
+            self.completions(message, model)
+        else:
+            self.chat_completions(message, model)
+
+    def completions(self, message, model):
+        stream = self.client.completions.create(
+            model=model,
+            prompt=message,
+            max_tokens=4090 - len(message),
+            temperature=0.1,
+            stream=True
+        )
+        completion_text = ''
+        with Live(console=console, refresh_per_second=8) as live:
+            for completion in stream:
+                for choice in completion.choices:
+                    completion_text += choice.text
+                    print_formatted(completion_text, live)
+        clip.set_text(completion_text)
+        print("\n")
+
+    def chat_completions(self, message, model):
+        message = {"role": "user", "content": message}
+        self.messages.append(message)
+        self.model = model
+        # Reset role for this chat session
+        self.role = None
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            final_text = loop.run_until_complete(self.print_streaming(self.async_stream))
+        except KeyboardInterrupt:
+            final_text = None
+        finally:
+            loop.close()
+
+        if final_text is None:
+            console.print("\n[bold red]Stream was interrupted or user exited (no final output).[/bold red]")
+            sys.exit(0)
+        md = Markdown(final_text)
+        self.append_to_history(final_text)
+        console.print(md)
+        clip.set_text(final_text)
+        # Ensure role is always set (default to 'assistant' if not returned by model)
+        response_role = self.role if self.role else "assistant"
+        self.record_chat_logs(message, {"role": response_role, "content": final_text.replace("\n\n", "")})
+
+    async def async_stream(self) -> AsyncGenerator[StreamChunk, None]:
+        """
+        Unified streaming generator that returns StreamChunk objects.
+        Handles both responses API (o1, codex) and chat.completions API (gpt-4, etc.)
+        """
+        # Detect which API to use
+        model_lower = self.model.lower()
+        use_responses_api = (
+            self.model.startswith('o1-') or 
+            self.model.startswith('o1') or
+            'codex' in model_lower
+        )
+        
+        if use_responses_api:
+            # Use responses API for o1 and codex models
+            response = self.client.responses.create(
+                model=self.model,
+                input=self.messages,
+                stream=True
+            )
+            
+            # Handle responses API streaming with event types
+            for event in response:
+                if hasattr(event, "type"):
+                    match event.type:
+                        case "response.output_text.delta":
+                            # Incremental text output
+                            yield StreamChunk(
+                                content=event.delta,
+                                event_type=event.type
+                            )
+                            await asyncio.sleep(0.01)
+                        
+                        case "response.output_text.done":
+                            # Text output completed
+                            yield StreamChunk(
+                                finish_reason="stop",
+                                event_type=event.type
+                            )
+                        
+                        case "response.output_item.done":
+                            # Item completed - only extract role if status is completed
+                            if hasattr(event, "item"):
+                                if hasattr(event.item, "status") and event.item.status == 'completed':
+                                    # Only get role when status is completed
+                                    if hasattr(event.item, "role"):
+                                        yield StreamChunk(
+                                            role=event.item.role,
+                                            finish_reason="completed",
+                                            event_type=event.type
+                                        )
+                                    else:
+                                        yield StreamChunk(
+                                            finish_reason="completed",
+                                            event_type=event.type
+                                        )
+                        
+                        case _:
+                            # Other event types, just pass through
+                            pass
+        else:
+            # Use chat.completions API for regular models
+            params = {
+                'model': self.model,
+                'messages': self.messages,
+                'temperature': 1,
+                'top_p': 1,
+                'frequency_penalty': 0.0,
+                'stream': True
+            }
+            
+            response = self.client.chat.completions.create(**params)
+            
+            for chunk in response:
+                if chunk.choices is None or len(chunk.choices) == 0:
+                    continue
+                    
+                choice = chunk.choices[0]
+                delta = choice.delta
+                
+                # Convert to unified StreamChunk format
+                yield StreamChunk(
+                    content=delta.content if hasattr(delta, 'content') else None,
+                    role=delta.role if hasattr(delta, 'role') else None,
+                    finish_reason=choice.finish_reason
+                )
+                await asyncio.sleep(0.01)
+
+    async def print_streaming(self, async_stream):
+        self.partial_text = []
+        text_area = TextArea(
+            text="",
+            wrap_lines=True,
+            read_only=True,
+        )
+        app = Application(layout=Layout(HSplit([text_area])), full_screen=False)
+
+        async def producer():
+            """
+            Process streaming chunks from either API in a unified way.
+            Handles StreamChunk objects regardless of source API.
+            """
+            try:
+                async for chunk in async_stream():
+                    # Handle finish conditions
+                    if chunk.finish_reason in ("stop", "completed"):
+                        # Extract role before finishing (for responses API)
+                        if chunk.role and self.role is None:
+                            self.role = chunk.role
+                        break
+                    
+                    # Extract role if provided (usually first chunk for chat.completions)
+                    if chunk.role and self.role is None:
+                        self.role = chunk.role
+                    
+                    # Append content if available
+                    if chunk.content:
+                        self.partial_text.append(chunk.content)
+                        joined = "".join(self.partial_text)
+                        text_area.text = joined
+                        text_area.buffer.cursor_position = len(text_area.buffer.text)
+                        app.invalidate()
+                
+                # Clear text area and exit
+                text_area.text = ""
+                app.invalidate()
+                app.exit()
+            except asyncio.CancelledError:
+                app.exit(result=None)
+            except Exception as e:
+                self.partial_text.append(f"\n\n[ERROR] {e}")
+                app.exit(result="".join(self.partial_text))
+
+        app.create_background_task(producer())
+        await app.run_async()
+        return "".join(self.partial_text)
+
+    def record_chat_logs(self, content, completion_text):
+        with open(self.file_name, 'r+') as f:
+            lines = f.readlines()
+            if len(lines) >= self.limit_history:
+                limit_history_ = (len(lines) + 2 - self.limit_history)
+                with open(os.path.join(self.folder_path, self.chat_log_id + '_history.log'), 'a+') as hf:
+                    hf.writelines("\n")
+                    hf.writelines(lines[:limit_history_])
+                lines = lines[limit_history_:]
+            if len(lines) == 0:
+                lines.append('{}\n{}'.format(json.dumps(content, ensure_ascii=False),
+                                             json.dumps(completion_text, ensure_ascii=False)))
+            else:
+                lines.append('\n{}\n{}'.format(json.dumps(content, ensure_ascii=False),
+                                               json.dumps(completion_text, ensure_ascii=False)))
+            f.seek(0)
+            f.truncate()
+            f.writelines(lines)
+
+    def append_to_history(self, md_text: str):
+        self.history_path.parent.mkdir(parents=True, exist_ok=True)
+        # 追加分隔符 + markdown 内容
+        with self.history_path.open("a", encoding="utf-8") as f:
+            f.write("\n\n---\n\n")
+            f.write(md_text)
+
+    def read_history(self) -> str:
+        if not self.history_path.exists():
+            return ""
+        return self.history_path.read_text(encoding="utf-8")
+
+
+if __name__ == '__main__':
+    command_chat = CommandChat()
+    command_chat.chat("帮我写一个python的冒泡排序算法", "o1-mini")

{commandchat-0.0.12 → commandchat-0.0.13}/occ/command/__main__.py

@@ -12,8 +12,7 @@ from pygments.styles.tango import TangoStyle
 
 import occ.utils.logger as logger
 from occ.CommandChat import CommandChat
-from occ.configuration.profile_config import add_profile, add_default_profile
-from occ.utils.CommonUtil import waiting_stop
+
 
 VERSION = importlib.metadata.version("commandchat")
 
@@ -25,12 +24,17 @@ def commandchat_operator():
 
 
 @click.command()
-@click.option('--profile', '-p', help='Enable profile name')
+@click.option('--profile', '-p', help='Specify profile name to configure')
 def configure(profile):
+    """Configure OpenAI or Azure OpenAI profiles"""
     if profile is not None:
-        add_profile(profile)
+        # If profile is specified, configure it directly
+        from occ.configuration.profile_config import configure_profile
+        configure_profile(profile)
     else:
-        add_default_profile()
+        # No profile specified, show interactive selection
+        from occ.configuration.profile_config import select_profile_interactively
+        select_profile_interactively()
 
 
 @click.command()
@@ -42,6 +46,64 @@ def configure(profile):
 @click.option('--file', '-f', type=click.Path(exists=True), help='the prompt or message is from a file')
 def chat(message, id, profile, model, file):
     try:
+        import questionary
+        from occ.commons import config as cfg
+        from questionary import Style
+        
+        custom_style = Style([
+            ('qmark', 'fg:#673ab7 bold'),
+            ('question', 'bold'),
+            ('answer', 'fg:#f44336 bold'),
+            ('pointer', 'fg:#673ab7 bold'),
+            ('highlighted', 'fg:#673ab7 bold'),
+        ])
+        
+        # Use default profile if none specified
+        active_profile = profile or "default"
+        
+        # Check if profile exists
+        if not cfg.profile_exists(active_profile):
+            logger.log_r(f"Profile '{active_profile}' does not exist. Please run 'occ configure' first.")
+            return
+        
+        # Check API server type
+        api_server_type = cfg.get_env(active_profile, 'api_server_type')
+        
+        # For azure-openai, check for multiple models
+        if api_server_type == 'azure-openai':
+            available_models = cfg.get_profile_models(active_profile)
+            
+            if not available_models:
+                logger.log_r(f"No models configured for profile '{active_profile}'. Please run 'occ configure' first.")
+                return
+            
+            # If user didn't specify model and there are multiple models, let them choose
+            if not model or model == "o1-mini":  # o1-mini is the default, treat as not specified
+                if len(available_models) > 1:
+                    # Interactive mode - let user select model
+                    if not message and not file and sys.stdin.isatty():
+                        model = questionary.select(
+                            "Select a model:",
+                            choices=available_models,
+                            style=custom_style
+                        ).ask()
+                        
+                        if model is None:
+                            logger.log_r("Model selection cancelled.")
+                            return
+                    else:
+                        # Non-interactive mode - use first available model
+                        model = available_models[0]
+                        logger.log_g(f"Using model: {model}")
+                else:
+                    # Only one model, use it
+                    model = available_models[0]
+            else:
+                # User specified a model, verify it exists
+                if model not in available_models:
+                    logger.log_r(f"Model '{model}' not found in profile '{active_profile}'. Available models: {', '.join(available_models)}")
+                    return
+        
         if file:
             with open(file, 'r') as f:
                 message = f.read()
@@ -67,15 +129,14 @@ def chat(message, id, profile, model, file):
                     if message.lower() in {"/exit", "/quit", "/q"}:
                         print_formatted_text(HTML("<ansired>Bye 👋</ansired>"))
                         exit(0)
-                    CommandChat(profile=profile, chat_log_id=id).chat(message, model)
+                    CommandChat(profile=active_profile, chat_log_id=id).chat(message, model)
                     print()
                 except KeyboardInterrupt:
                     print_formatted_text(HTML("<ansired>\n(Interrupted)</ansired>"))
                     exit(0)
-        CommandChat(profile=profile, chat_log_id=id).chat(message, model)
+        CommandChat(profile=active_profile, chat_log_id=id).chat(message, model)
     except Exception as e:
         logger.log_g(str(e))
-        waiting_stop()
 
 
 size_map = {

{commandchat-0.0.12 → commandchat-0.0.13}/occ/commons/config.py

@@ -71,10 +71,8 @@ def get_env(profile, key):
     if config.has_option('default', key):
         return config.get('default', key)
 
-    logger.debug("No Value Found in DEAFULT SECTION as well")
-    logger.log_r(
-        'Value not found in [Default Profile] use `occ configure`comamnd')
-    exit()
+    logger.debug("No Value Found in DEFAULT SECTION as well")
+    return None
 
 
 def get_default_env(key):
@@ -84,7 +82,64 @@ def get_default_env(key):
 
 
 def get_profiles():
-    return config.sections()
+    """Get all profile names (excluding model-specific sections)"""
+    profiles = []
+    for section in config.sections():
+        # Filter out model-specific sections (e.g., profile_name.model_name)
+        if '.' not in section:
+            profiles.append(section)
+    return profiles
+
+
+def get_profile_models(profile):
+    """Get all models configured for a specific profile"""
+    models = []
+    prefix = f"{profile}."
+    for section in config.sections():
+        if section.startswith(prefix):
+            model_name = section[len(prefix):]
+            models.append(model_name)
+    return models
+
+
+def get_model_config(profile, model):
+    """Get configuration for a specific model under a profile"""
+    section = f"{profile}.{model}"
+    if not config.has_section(section):
+        return None
+    return {
+        'api_key': config.get(section, 'api_key', fallback=None),
+        'api_base_url': config.get(section, 'api_base_url', fallback=None),
+        'api_version': config.get(section, 'api_version', fallback=None)
+    }
+
+
+def set_model_config(profile, model, api_key, api_base_url, api_version):
+    """Set configuration for a specific model under a profile"""
+    section = f"{profile}.{model}"
+    if not config.has_section(section):
+        config.add_section(section)
+    config.set(section, 'api_key', api_key)
+    config.set(section, 'api_base_url', api_base_url)
+    config.set(section, 'api_version', api_version)
+    write_config()
+
+
+def remove_profile(profile):
+    """Remove a profile and all its associated models"""
+    if config.has_section(profile):
+        config.remove_section(profile)
+    # Remove all model sections
+    prefix = f"{profile}."
+    for section in list(config.sections()):
+        if section.startswith(prefix):
+            config.remove_section(section)
+    write_config()
+
+
+def profile_exists(profile):
+    """Check if a profile exists"""
+    return config.has_section(profile)
 
 
 def log_config():

commandchat-0.0.13/occ/configuration/profile_config.py

@@ -0,0 +1,262 @@
+import questionary
+from questionary import Style
+
+import occ.commons.config as config
+import occ.utils.logger as logger
+
+# Custom style for questionary
+custom_style = Style([
+    ('qmark', 'fg:#673ab7 bold'),
+    ('question', 'bold'),
+    ('answer', 'fg:#f44336 bold'),
+    ('pointer', 'fg:#673ab7 bold'),
+    ('highlighted', 'fg:#673ab7 bold'),
+    ('selected', 'fg:#cc5454'),
+    ('separator', 'fg:#cc5454'),
+    ('instruction', ''),
+    ('text', ''),
+])
+
+API_SERVER_TYPES = ['openai', 'azure-openai']
+
+
+def select_profile_interactively():
+    """Show a list of profiles and let user select one"""
+    profiles = config.get_profiles()
+    if not profiles:
+        logger.log_r("No profiles found. Creating default profile...")
+        configure_profile('default')
+        return
+    
+    choices = profiles + ['[Create New Profile]']
+    selected = questionary.select(
+        "Select a profile to configure:",
+        choices=choices,
+        style=custom_style
+    ).ask()
+    
+    if selected is None:
+        logger.log_r("Configuration cancelled.")
+        return
+    
+    if selected == '[Create New Profile]':
+        profile_name = questionary.text(
+            "Enter new profile name:",
+            style=custom_style
+        ).ask()
+        if profile_name:
+            configure_profile(profile_name)
+    else:
+        configure_profile(selected)
+
+
+def configure_profile(profile_name):
+    """Configure a profile (create new or update existing)"""
+    is_existing = config.profile_exists(profile_name)
+    
+    if is_existing:
+        logger.log_g(f"\nConfiguring existing profile: {profile_name}")
+    else:
+        logger.log_g(f"\nCreating new profile: {profile_name}")
+        config.add_profile(profile_name)
+    
+    # Common configuration
+    configure_common_settings(profile_name, is_existing)
+    
+    # API server type specific configuration
+    api_server_type = config.get_env(profile_name, 'api_server_type') if is_existing else None
+    api_server_type = questionary.select(
+        "Select API server type:",
+        choices=API_SERVER_TYPES,
+        default=api_server_type if api_server_type in API_SERVER_TYPES else API_SERVER_TYPES[0],
+        style=custom_style
+    ).ask()
+    
+    if api_server_type is None:
+        logger.log_r("Configuration cancelled.")
+        return
+    
+    config.set_env(profile_name, 'api_server_type', api_server_type)
+    
+    if api_server_type == 'openai':
+        configure_openai(profile_name, is_existing)
+    elif api_server_type == 'azure-openai':
+        configure_azure_openai(profile_name, is_existing)
+    
+    logger.log_g(f"\n✓ Profile '{profile_name}' configured successfully!")
+
+
+def configure_common_settings(profile_name, is_existing):
+    """Configure common settings for all API types"""
+    default_limit = '4'
+    if is_existing:
+        existing_limit = config.get_env(profile_name, 'limit_history')
+        if existing_limit:
+            default_limit = existing_limit
+    
+    limit_history = questionary.text(
+        "Limit history (number of messages to keep):",
+        default=default_limit,
+        style=custom_style
+    ).ask()
+    
+    if limit_history:
+        config.set_env(profile_name, 'limit_history', limit_history)
+
+
+def configure_openai(profile_name, is_existing):
+    """Configure OpenAI specific settings"""
+    default_key = ''
+    default_url = 'https://api.openai.com/v1'
+    
+    if is_existing:
+        existing_key = config.get_env(profile_name, 'api_key')
+        existing_url = config.get_env(profile_name, 'api_base_url')
+        if existing_key:
+            default_key = existing_key
+        if existing_url:
+            default_url = existing_url
+    
+    api_key = questionary.password(
+        "OpenAI API Key:",
+        default=default_key,
+        style=custom_style
+    ).ask()
+    
+    api_base_url = questionary.text(
+        "API Base URL:",
+        default=default_url,
+        style=custom_style
+    ).ask()
+    
+    if api_key:
+        config.set_env(profile_name, 'api_key', api_key)
+    if api_base_url:
+        config.set_env(profile_name, 'api_base_url', api_base_url)
+
+
+def configure_azure_openai(profile_name, is_existing):
+    """Configure Azure OpenAI with multiple models"""
+    logger.log_g("\nConfiguring Azure OpenAI models...")
+    
+    # Get existing models
+    existing_models = config.get_profile_models(profile_name)
+    
+    while True:
+        if existing_models:
+            logger.log_g(f"\nExisting models: {', '.join(existing_models)}")
+            action = questionary.select(
+                "What would you like to do?",
+                choices=[
+                    'Add new model',
+                    'Edit existing model',
+                    'Remove model',
+                    'Finish configuration'
+                ],
+                style=custom_style
+            ).ask()
+            
+            if action is None or action == 'Finish configuration':
+                break
+            elif action == 'Add new model':
+                add_azure_model(profile_name)
+                existing_models = config.get_profile_models(profile_name)
+            elif action == 'Edit existing model':
+                model_to_edit = questionary.select(
+                    "Select model to edit:",
+                    choices=existing_models,
+                    style=custom_style
+                ).ask()
+                if model_to_edit:
+                    edit_azure_model(profile_name, model_to_edit)
+            elif action == 'Remove model':
+                model_to_remove = questionary.select(
+                    "Select model to remove:",
+                    choices=existing_models,
+                    style=custom_style
+                ).ask()
+                if model_to_remove:
+                    remove_azure_model(profile_name, model_to_remove)
+                    existing_models = config.get_profile_models(profile_name)
+        else:
+            logger.log_g("\nNo models configured yet.")
+            should_add = questionary.confirm(
+                "Add a model?",
+                default=True,
+                style=custom_style
+            ).ask()
+            
+            if should_add:
+                add_azure_model(profile_name)
+                existing_models = config.get_profile_models(profile_name)
+            else:
+                break
+
+
+def add_azure_model(profile_name):
+    """Add a new Azure OpenAI model"""
+    model_name = questionary.text(
+        "Model name (e.g., gpt-4, gpt-35-turbo):",
+        style=custom_style
+    ).ask()
+    
+    if not model_name:
+        return
+    
+    edit_azure_model(profile_name, model_name)
+
+
+def edit_azure_model(profile_name, model_name):
+    """Edit Azure OpenAI model configuration"""
+    # Get existing config if available
+    existing_config = config.get_model_config(profile_name, model_name)
+    
+    api_key = questionary.password(
+        f"API Key for {model_name}:",
+        default=existing_config.get('api_key', '') if existing_config else '',
+        style=custom_style
+    ).ask()
+    
+    api_base_url = questionary.text(
+        f"Azure endpoint URL for {model_name}:",
+        default=existing_config.get('api_base_url', '') if existing_config else '',
+        style=custom_style
+    ).ask()
+    
+    api_version = questionary.text(
+        f"API version for {model_name}:",
+        default=existing_config.get('api_version', '2024-02-15-preview') if existing_config else '2024-02-15-preview',
+        style=custom_style
+    ).ask()
+    
+    if api_key and api_base_url and api_version:
+        config.set_model_config(profile_name, model_name, api_key, api_base_url, api_version)
+        logger.log_g(f"✓ Model '{model_name}' configured successfully!")
+    else:
+        logger.log_r("Configuration incomplete. Model not saved.")
+
+
+def remove_azure_model(profile_name, model_name):
+    """Remove an Azure OpenAI model configuration"""
+    confirm = questionary.confirm(
+        f"Are you sure you want to remove model '{model_name}'?",
+        default=False,
+        style=custom_style
+    ).ask()
+    
+    if confirm:
+        section = f"{profile_name}.{model_name}"
+        config.config.remove_section(section)
+        config.write_config()
+        logger.log_g(f"✓ Model '{model_name}' removed.")
+
+
+# Legacy functions for backward compatibility
+def add_default_profile():
+    """Legacy function - redirects to new configure_profile"""
+    configure_profile('default')
+
+
+def add_profile(profile_name):
+    """Legacy function - redirects to new configure_profile"""
+    configure_profile(profile_name)

{commandchat-0.0.12 → commandchat-0.0.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "commandchat"
-version = "0.0.12"
+version = "0.0.13"
 description = "use command to chat with openai models"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -17,7 +17,10 @@ dependencies = [
     "Image",
     "openai",
     "prompt_toolkit",
+    "pyperclip",
     "rich",
+    "requests",
+    "questionary",
 ]
 
 classifiers = [

commandchat-0.0.12/occ/CommandChat.py

@@ -1,209 +0,0 @@
-import asyncio
-import json
-import os
-import sys
-import time
-from pathlib import Path
-from typing import AsyncGenerator
-
-from openai import AzureOpenAI
-from openai import OpenAI
-from openai.types.chat.chat_completion_chunk import Choice
-from prompt_toolkit import print_formatted_text, HTML, Application
-from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
-from prompt_toolkit.layout import Layout, HSplit
-from prompt_toolkit.widgets import TextArea
-from rich.console import Console
-from rich.live import Live
-from rich.markdown import Markdown
-
-from occ.commons.config import get_env
-
-DEFAULT_CHAT_LOG_ID = "chat-1"
-DEFAULT_PROFILE = "default"
-USER_COLOR = "ansiyellow"
-ASSISTANT_COLOR = "ansicyan"
-TYPING_DELAY = 0.01  # 打字速度（秒/字符）
-SEPARATOR = "─" * 30
-
-
-def get_home_path():
-    homedir = os.environ.get('HOME', None)
-    if os.name == 'nt':
-        homedir = os.path.expanduser('~')
-    return homedir
-
-
-clip = PyperclipClipboard()
-console = Console()
-
-def print_formatted(content: str, live: Live):
-    md = Markdown(content)
-    live.update(md)
-    sys.stdout.flush()
-
-
-class CommandChat:
-    partial_text = []
-    role = None
-
-    def __init__(self, profile=None, chat_log_id=None):
-        now = time.strftime("%Y%m%d", time.localtime())
-        self.api_key = get_env(profile or DEFAULT_PROFILE, "api_key")
-        self.api_base = get_env(profile or DEFAULT_PROFILE, "api_base_url")
-        os.environ.setdefault("OPENAI_API_KEY", self.api_key)
-        os.environ.setdefault("OPENAI_BASE_URL", self.api_base)
-        self.limit_history = int(get_env(profile or DEFAULT_PROFILE, "limit_history") or 4)
-        self.chat_log_id = chat_log_id or DEFAULT_CHAT_LOG_ID
-        self.folder_path = os.path.join(get_home_path(), ".occ", profile or DEFAULT_PROFILE)
-        self.image_folder_path = os.path.join(self.folder_path, "images")
-        self.file_name = os.path.join(self.folder_path, f"{self.chat_log_id}.log")
-        os.makedirs(self.folder_path, exist_ok=True)
-        os.makedirs(self.image_folder_path, exist_ok=True)
-        self.model = None
-        if not os.path.exists(self.file_name):
-            open(self.file_name, 'w').close()
-        self.history_path = Path(self.folder_path, self.chat_log_id) / f"md_history_{now}.md"
-        self.messages = [json.loads(line) for line in (line.strip() for line in open(self.file_name)) if line.strip()]
-        if "azure" == get_env(profile or DEFAULT_PROFILE, "api_server_type"):
-            self.client = AzureOpenAI(api_key=self.api_key,
-                                      api_version=get_env(profile or DEFAULT_PROFILE, "api_version"),
-                                      azure_endpoint=self.api_base)
-        else:
-            self.client = OpenAI()
-
-    def image_create(self, description, size, num):
-        raise NotImplementedError
-
-    def chat(self, message, model):
-        print_formatted_text(HTML(f"<{ASSISTANT_COLOR}>🤖 Assistant: </{ASSISTANT_COLOR}>"))
-        if model == "gpt-35-turbo-instruct":
-            self.completions(message, model)
-        else:
-            self.chat_completions(message, model)
-
-    def completions(self, message, model):
-        stream = self.client.completions.create(
-            model=model,
-            prompt=message,
-            max_tokens=4090 - len(message),
-            temperature=0.1,
-            stream=True
-        )
-        completion_text = ''
-        with Live(console=console, refresh_per_second=8) as live:
-            for completion in stream:
-                for choice in completion.choices:
-                    completion_text += choice.text
-                    print_formatted(completion_text, live)
-        clip.set_text(completion_text)
-        print("\n")
-
-    def chat_completions(self, message, model):
-        message = {"role": "user", "content": message}
-        self.messages.append(message)
-        self.model = model
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            final_text = loop.run_until_complete(self.print_streaming(self.async_stream))
-        except KeyboardInterrupt:
-            final_text = None
-        finally:
-            loop.close()
-
-        if final_text is None:
-            console.print("\n[bold red]Stream was interrupted or user exited (no final output).[/bold red]")
-            sys.exit(0)
-        md = Markdown(final_text)
-        self.append_to_history(final_text)
-        console.print(md)
-        clip.set_text(final_text)
-        self.record_chat_logs(message, {"role": self.role, "content": final_text.replace("\n\n", "")})
-
-    async def async_stream(self) -> AsyncGenerator[Choice, None]:
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=self.messages,
-            temperature=1,
-            top_p=1,
-            frequency_penalty=0.0,
-            stream=True
-        )
-        for chunk in response:
-            if chunk.choices is None or len(chunk.choices) == 0:
-                continue
-            choice = chunk.choices[0]
-            await asyncio.sleep(0.01)
-            yield choice
-
-    async def print_streaming(self, async_stream):
-        self.partial_text = []
-        text_area = TextArea(
-            text="",
-            wrap_lines=True,
-            read_only=True,
-        )
-        app = Application(layout=Layout(HSplit([text_area])), full_screen=False)
-
-        async def producer():
-            try:
-                async for chunk in async_stream():
-                    delta = chunk.delta
-                    if chunk.finish_reason == "stop": break
-                    if self.role is None and delta.role:
-                        self.role = delta.role
-                    if delta.content:
-                        self.partial_text.append(delta.content)
-                        joined = "".join(self.partial_text)
-                        text_area.text = joined
-                        text_area.buffer.cursor_position = len(text_area.buffer.text)
-                        app.invalidate()
-                text_area.text = ""
-                app.invalidate()
-                app.exit()
-            except asyncio.CancelledError:
-                app.exit(result=None)
-            except Exception as e:
-                self.partial_text.append(f"\n\n[ERROR] {e}")
-                app.exit(result="".join(self.partial_text))
-
-        app.create_background_task(producer())
-        await app.run_async()
-        return "".join(self.partial_text)
-
-    def record_chat_logs(self, content, completion_text):
-        with open(self.file_name, 'r+') as f:
-            lines = f.readlines()
-            if len(lines) >= self.limit_history:
-                limit_history_ = (len(lines) + 2 - self.limit_history)
-                with open(os.path.join(self.folder_path, self.chat_log_id + '_history.log'), 'a+') as hf:
-                    hf.writelines("\n")
-                    hf.writelines(lines[:limit_history_])
-                lines = lines[limit_history_:]
-            if len(lines) == 0:
-                lines.append('{}\n{}'.format(json.dumps(content, ensure_ascii=False),
-                                             json.dumps(completion_text, ensure_ascii=False)))
-            else:
-                lines.append('\n{}\n{}'.format(json.dumps(content, ensure_ascii=False),
-                                               json.dumps(completion_text, ensure_ascii=False)))
-            f.seek(0)
-            f.truncate()
-            f.writelines(lines)
-
-    def append_to_history(self, md_text: str):
-        self.history_path.parent.mkdir(parents=True, exist_ok=True)
-        # 追加分隔符 + markdown 内容
-        with self.history_path.open("a", encoding="utf-8") as f:
-            f.write("\n\n---\n\n")
-            f.write(md_text)
-
-    def read_history(self) -> str:
-        if not self.history_path.exists():
-            return ""
-        return self.history_path.read_text(encoding="utf-8")
-
-
-if __name__ == '__main__':
-    command_chat = CommandChat()
-    command_chat.chat("帮我写一个python的冒泡排序算法", "o1-mini")

commandchat-0.0.12/occ/configuration/profile_config.py

@@ -1,46 +0,0 @@
-import click
-
-import occ.commons.config as config
-import occ.utils.logger as logger
-
-
-def add_default_profile():
-    api_key = click.prompt(logger.style('\n[default] Your default api_key '),
-                           default=config.get_default_env("api_key"), type=str)
-    config.set_env('default', 'api_key', api_key)
-
-    api_base_url = click.prompt(logger.style('\n[default] Your api_base_url(Optional) '),
-                           default=config.get_default_env("api_base_url"), type=str)
-    config.set_env('default', 'api_base_url', api_base_url)
-
-    limit_history = click.prompt(logger.style('\n[default] Your default limit_history '),
-                                 default=config.get_default_env("limit_history"), type=str)
-    config.set_env('default', 'limit_history', limit_history)
-
-    api_server_type = click.prompt(logger.style('\n[default] Your default api_server_type '),
-                                 default=config.get_default_env("api_server_type"), type=str)
-    config.set_env('default', 'api_server_type', api_server_type)
-
-    api_version = click.prompt(logger.style('\n[default] Your default api_version '),
-                                 default=config.get_default_env("api_version"), type=str)
-    config.set_env('default', 'api_version', api_version)
-
-
-def input_config_vars(profile_name, key_name, is_default_exist):
-    if is_default_exist:
-        default_value = config.get_env('default', key_name)
-        user_input = click.prompt(logger.style('\ndefault value  ' + key_name), default=default_value, type=str)
-    else:
-        user_input = click.prompt(logger.style('\nYour ' + key_name), type=str)
-
-    config.set_env(profile_name, key_name, user_input)
-
-
-def add_profile(profile_name):
-    config.add_profile(profile_name)
-    config.set_env(profile_name, 'profile_name', profile_name)
-    input_config_vars(profile_name, 'api_key', False)
-    input_config_vars(profile_name, 'api_base_url', False)
-    input_config_vars(profile_name, 'limit_history', False)
-    input_config_vars(profile_name, 'api_server_type', False)
-    input_config_vars(profile_name, 'api_version', False)