codemate-cli 1.0.0__py3-none-any.whl

codemate/config.py

@@ -0,0 +1,233 @@
+import os
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+
+class Config:
+    """Configuration manager for CodeMate CLI"""
+    
+    def __init__(self):
+        self.config_dir = self._get_config_dir()
+        self.config_file = self.config_dir / "cli_config.json"
+        self.session_file = self.config_dir / "session.txt"
+        self._ensure_config_exists()
+        self._load_config()
+    
+    def _get_config_dir(self) -> Path:
+        """Get or create config directory in user home"""
+        # Use user home directory + .codemate/user
+        home = Path.home()
+        config_dir = home / ".codemate" / "user"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        return config_dir
+    
+    def _ensure_config_exists(self):
+        """Create config file if it doesn't exist"""
+        if not self.config_file.exists():
+            default_config = {
+                "endpoint": "http://localhost:45223",
+                "default_model": "chat_c0_cli",
+                "stream": True,
+                "theme": "monokai",
+                "save_history": True,
+            }
+            self._save_config(default_config)
+    
+    def _load_config(self):
+        """Load configuration from file"""
+        try:
+            with open(self.config_file, 'r') as f:
+                self.config = json.load(f)
+        except Exception as e:
+            print(f"Warning: Could not load config: {e}")
+            self.config = {}
+    
+    def _save_config(self, config: Dict[str, Any]):
+        """Save configuration to file"""
+        try:
+            with open(self.config_file, 'w') as f:
+                json.dump(config, f, indent=2)
+            self.config = config
+        except Exception as e:
+            print(f"Error saving config: {e}")
+    
+    def is_logged_in(self) -> bool:
+        """Check if user is logged in by checking session.txt existence"""
+        return self.session_file.exists()
+    
+    def get_session(self) -> Optional[str]:
+        """Get session from session.txt file"""
+        if not self.session_file.exists():
+            return None
+        
+        try:
+            with open(self.session_file, 'r') as f:
+                session = f.read().strip()
+                return session if session else None
+        except Exception:
+            return None
+    
+    def save_session(self, session: str):
+        """Save session to session.txt file"""
+        try:
+            with open(self.session_file, 'w') as f:
+                f.write(session)
+        except Exception as e:
+            print(f"Error saving session: {e}")
+    
+    def clear_session(self):
+        """Clear session (logout)"""
+        if self.session_file.exists():
+            self.session_file.unlink()
+    
+    def get_api_key(self) -> Optional[str]:
+        """Get API key from session.txt (for backward compatibility)"""
+        return self.get_session()
+    
+    def set_api_key(self, api_key: str):
+        """Set API key in session.txt (for backward compatibility)"""
+        self.save_session(api_key)
+    
+    def get_endpoint(self) -> str:
+        """Get API endpoint"""
+        return os.environ.get('CODEMATE_ENDPOINT') or self.config.get(
+            'endpoint', 
+            'http://localhost:45223'
+        )
+    
+    def set_endpoint(self, endpoint: str):
+        """Set API endpoint"""
+        self.config['endpoint'] = endpoint
+        self._save_config(self.config)
+    
+    def get_default_model(self) -> str:
+        """Get default model"""
+        return self.config.get('default_model', 'chat_c0_cli')
+    
+    def set_default_model(self, model: str):
+        """Set default model"""
+        self.config['default_model'] = model
+        self._save_config(self.config)
+    
+    def get_stream_enabled(self) -> bool:
+        """Check if streaming is enabled"""
+        return self.config.get('stream', True)
+    
+    def set_stream_enabled(self, enabled: bool):
+        """Enable/disable streaming"""
+        self.config['stream'] = enabled
+        self._save_config(self.config)
+    
+    def get_theme(self) -> str:
+        """Get code theme"""
+        return self.config.get('theme', 'monokai')
+    
+    def set_theme(self, theme: str):
+        """Set code theme"""
+        self.config['theme'] = theme
+        self._save_config(self.config)
+    
+    def get_save_history(self) -> bool:
+        """Check if history saving is enabled"""
+        return self.config.get('save_history', True)
+    
+    def set_save_history(self, enabled: bool):
+        """Enable/disable history saving"""
+        self.config['save_history'] = enabled
+        self._save_config(self.config)
+    
+    def get_all(self) -> Dict[str, Any]:
+        """Get all configuration values"""
+        session = self.get_session()
+        return {
+            "logged_in": self.is_logged_in(),
+            "session": session[:10] + "..." + session[-4:] if session and len(session) > 14 else "Not logged in",
+            "endpoint": self.get_endpoint(),
+            "default_model": self.get_default_model(),
+            "stream": self.get_stream_enabled(),
+            "theme": self.get_theme(),
+            "save_history": self.get_save_history(),
+            "config_location": str(self.config_file),
+            "session_location": str(self.session_file),
+        }
+    
+    def reset(self):
+        """Reset configuration to defaults"""
+        self.config_file.unlink(missing_ok=True)
+        self._ensure_config_exists()
+        self._load_config()
+
+
+class HistoryManager:
+    """Manage conversation history"""
+    
+    def __init__(self, config: Config):
+        self.config = config
+        self.history_dir = config.config_dir / "history"
+        self.history_dir.mkdir(exist_ok=True)
+        self.current_session_file = self.history_dir / "current_session.json"
+    
+    def save_message(self, role: str, content: str, metadata: Optional[Dict] = None):
+        """Save a message to current session"""
+        if not self.config.get_save_history():
+            return
+        
+        try:
+            # Load existing history
+            history = []
+            if self.current_session_file.exists():
+                with open(self.current_session_file, 'r') as f:
+                    history = json.load(f)
+            
+            # Add new message
+            message = {
+                "role": role,
+                "content": content,
+                "timestamp": self._get_timestamp(),
+            }
+            if metadata:
+                message["metadata"] = metadata
+            
+            history.append(message)
+            
+            # Save updated history
+            with open(self.current_session_file, 'w') as f:
+                json.dump(history, f, indent=2)
+        
+        except Exception as e:
+            print(f"Warning: Could not save history: {e}")
+    
+    def load_current_session(self) -> list:
+        """Load current session history"""
+        try:
+            if self.current_session_file.exists():
+                with open(self.current_session_file, 'r') as f:
+                    return json.load(f)
+        except Exception:
+            pass
+        return []
+    
+    def clear_current_session(self):
+        """Clear current session history"""
+        self.current_session_file.unlink(missing_ok=True)
+    
+    def archive_session(self, name: Optional[str] = None):
+        """Archive current session with optional name"""
+        if not self.current_session_file.exists():
+            return
+        
+        timestamp = self._get_timestamp()
+        archive_name = name or f"session_{timestamp}.json"
+        archive_path = self.history_dir / archive_name
+        
+        self.current_session_file.rename(archive_path)
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp"""
+        from datetime import datetime
+        return datetime.now().isoformat()

codemate/ui/__init__.py

@@ -0,0 +1,10 @@
+"""
+UI components for CodeMate CLI
+"""
+
+from codemate.ui.streaming import StreamingHandler, MarkdownRenderer
+
+__all__ = [
+    "StreamingHandler",
+    "MarkdownRenderer",
+]

codemate/ui/markdown.py

@@ -0,0 +1,212 @@
+"""
+Enhanced Markdown rendering utilities
+"""
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+import re
+from typing import Optional
+
+
+class MarkdownProcessor:
+    """Process and enhance markdown content"""
+    
+    def __init__(self):
+        self.code_block_pattern = re.compile(r'```(\w+)?\n(.*?)```', re.DOTALL)
+    
+    def extract_code_blocks(self, text: str):
+        """Extract code blocks from markdown"""
+        blocks = []
+        for match in self.code_block_pattern.finditer(text):
+            language = match.group(1) or "text"
+            code = match.group(2)
+            blocks.append({
+                "language": language,
+                "code": code,
+                "start": match.start(),
+                "end": match.end()
+            })
+        return blocks
+    
+    def replace_code_blocks(self, text: str, placeholder: str = "[CODE_BLOCK]"):
+        """Replace code blocks with placeholder"""
+        return self.code_block_pattern.sub(placeholder, text)
+    
+    def split_by_code_blocks(self, text: str):
+        """Split text into markdown and code sections"""
+        sections = []
+        last_end = 0
+        
+        for match in self.code_block_pattern.finditer(text):
+            # Add markdown before code block
+            if match.start() > last_end:
+                sections.append({
+                    "type": "markdown",
+                    "content": text[last_end:match.start()]
+                })
+            
+            # Add code block
+            sections.append({
+                "type": "code",
+                "language": match.group(1) or "text",
+                "content": match.group(2)
+            })
+            
+            last_end = match.end()
+        
+        # Add remaining markdown
+        if last_end < len(text):
+            sections.append({
+                "type": "markdown",
+                "content": text[last_end:]
+            })
+        
+        return sections
+
+
+class EnhancedMarkdownRenderer:
+    """Enhanced markdown renderer with custom styling"""
+    
+    def __init__(self, console: Console, theme: str = "monokai"):
+        self.console = console
+        self.theme = theme
+        self.processor = MarkdownProcessor()
+    
+    def render(
+        self,
+        markdown_text: str,
+        title: Optional[str] = None,
+        show_panel: bool = True
+    ):
+        """
+        Render markdown with enhanced styling
+        
+        Args:
+            markdown_text: Markdown text to render
+            title: Optional title for panel
+            show_panel: Whether to wrap in a panel
+        """
+        # Split content into sections
+        sections = self.processor.split_by_code_blocks(markdown_text)
+        
+        if show_panel:
+            self.console.print()  # Add spacing
+        
+        for section in sections:
+            if section["type"] == "markdown":
+                # Render markdown
+                if section["content"].strip():
+                    md = Markdown(section["content"], code_theme=self.theme)
+                    if show_panel:
+                        self.console.print(md)
+                    else:
+                        self.console.print(md)
+            
+            elif section["type"] == "code":
+                # Render code with syntax highlighting
+                self.render_code_block(
+                    section["content"],
+                    section["language"]
+                )
+        
+        if show_panel:
+            self.console.print()  # Add spacing
+    
+    def render_code_block(self, code: str, language: str = "python"):
+        """Render a single code block with syntax highlighting"""
+        syntax = Syntax(
+            code.strip(),
+            language,
+            theme=self.theme,
+            line_numbers=True,
+            word_wrap=False,
+            background_color="default"
+        )
+        
+        self.console.print(Panel(
+            syntax,
+            border_style="#48AEF3",
+            padding=(0, 1),
+            title=f"[bold color(#48AEF3)]{language.upper()}[/bold color(#48AEF3)]",
+            title_align="left"
+        ))
+    
+    def render_inline(self, markdown_text: str):
+        """Render markdown inline without panels"""
+        md = Markdown(markdown_text, code_theme=self.theme)
+        self.console.print(md)
+    
+    def render_with_title(self, markdown_text: str, title: str):
+        """Render markdown with a title panel"""
+        md = Markdown(markdown_text, code_theme=self.theme)
+        self.console.print(Panel(
+            md,
+            title=f"[bold color(#2FCACE)]{title}[/bold color(#2FCACE)]",
+            border_style="#2FCACE",
+            padding=(1, 2)
+        ))
+
+
+class MarkdownFormatter:
+    """Format text into markdown"""
+    
+    @staticmethod
+    def heading(text: str, level: int = 1) -> str:
+        """Create markdown heading"""
+        return f"{'#' * level} {text}\n"
+    
+    @staticmethod
+    def bold(text: str) -> str:
+        """Make text bold"""
+        return f"**{text}**"
+    
+    @staticmethod
+    def italic(text: str) -> str:
+        """Make text italic"""
+        return f"*{text}*"
+    
+    @staticmethod
+    def code(text: str) -> str:
+        """Make inline code"""
+        return f"`{text}`"
+    
+    @staticmethod
+    def code_block(code: str, language: str = "python") -> str:
+        """Create code block"""
+        return f"```{language}\n{code}\n```\n"
+    
+    @staticmethod
+    def link(text: str, url: str) -> str:
+        """Create link"""
+        return f"[{text}]({url})"
+    
+    @staticmethod
+    def list_item(text: str, ordered: bool = False, number: int = 1) -> str:
+        """Create list item"""
+        if ordered:
+            return f"{number}. {text}\n"
+        return f"- {text}\n"
+    
+    @staticmethod
+    def table(headers: list, rows: list) -> str:
+        """Create markdown table"""
+        # Header row
+        table = "| " + " | ".join(headers) + " |\n"
+        # Separator
+        table += "| " + " | ".join(["---"] * len(headers)) + " |\n"
+        # Data rows
+        for row in rows:
+            table += "| " + " | ".join(str(cell) for cell in row) + " |\n"
+        return table
+    
+    @staticmethod
+    def quote(text: str) -> str:
+        """Create blockquote"""
+        return f"> {text}\n"
+    
+    @staticmethod
+    def horizontal_rule() -> str:
+        """Create horizontal rule"""
+        return "---\n"

codemate/ui/renderer.py

@@ -0,0 +1,159 @@
+"""
+Rich rendering utilities for beautiful terminal output
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+from rich.markdown import Markdown
+from rich.text import Text
+from typing import List, Dict, Any, Optional
+
+
+class UIRenderer:
+    """Utility class for rendering rich UI components"""
+    
+    def __init__(self, console: Console):
+        self.console = console
+    
+    def render_panel(
+        self,
+        content: str,
+        title: Optional[str] = None,
+        border_style: str = "#2FCACE",
+        padding: tuple = (1, 2)
+    ):
+        """Render content in a panel"""
+        panel = Panel(
+            content,
+            title=title,
+            border_style=border_style,
+            padding=padding
+        )
+        self.console.print(panel)
+    
+    def render_table(
+        self,
+        data: List[Dict[str, Any]],
+        title: Optional[str] = None,
+        columns: Optional[List[str]] = None
+    ):
+        """Render data as a table"""
+        if not data:
+            self.console.print("[yellow]No data to display[/yellow]")
+            return
+        
+        # Get columns from first row if not provided
+        if columns is None:
+            columns = list(data[0].keys())
+        
+        table = Table(title=title, show_header=True, header_style="bold magenta")
+
+        # Add columns
+        for col in columns:
+            table.add_column(col, style="#2FCACE")
+        
+        # Add rows
+        for row in data:
+            table.add_row(*[str(row.get(col, "")) for col in columns])
+        
+        self.console.print(table)
+    
+    def render_code(
+        self,
+        code: str,
+        language: str = "python",
+        theme: str = "monokai",
+        line_numbers: bool = True
+    ):
+        """Render syntax-highlighted code"""
+        syntax = Syntax(
+            code,
+            language,
+            theme=theme,
+            line_numbers=line_numbers,
+            word_wrap=False
+        )
+        self.console.print(syntax)
+    
+    def render_markdown(self, markdown_text: str, code_theme: str = "monokai"):
+        """Render markdown content"""
+        markdown = Markdown(markdown_text, code_theme=code_theme)
+        self.console.print(markdown)
+    
+    def render_success(self, message: str):
+        """Render success message"""
+        self.console.print(f"[green]✓ {message}[/green]")
+    
+    def render_error(self, message: str):
+        """Render error message"""
+        self.console.print(f"[red]✗ {message}[/red]")
+    
+    def render_warning(self, message: str):
+        """Render warning message"""
+        self.console.print(f"[yellow]⚠ {message}[/yellow]")
+    
+    def render_info(self, message: str):
+        """Render info message"""
+        self.console.print(f"[color(#48AEF3)]ℹ {message}[/color(#48AEF3)]")
+    
+    def render_list(
+        self,
+        items: List[str],
+        title: Optional[str] = None,
+        style: str = "#2FCACE"
+    ):
+        """Render a list of items"""
+        if title:
+            self.console.print(f"\n[bold {style}]{title}[/bold {style}]")
+        
+        for item in items:
+            self.console.print(f"  • {item}")
+    
+    def render_key_value_pairs(
+        self,
+        data: Dict[str, Any],
+        title: Optional[str] = None
+    ):
+        """Render key-value pairs"""
+        table = Table(title=title, show_header=False, box=None)
+        table.add_column("Key", style="#2FCACE", justify="right")
+        table.add_column("Value", style="white")
+        
+        for key, value in data.items():
+            table.add_row(f"{key}:", str(value))
+        
+        self.console.print(table)
+    
+    def clear_screen(self):
+        """Clear the terminal screen"""
+        self.console.clear()
+    
+    def render_separator(self, char: str = "─", style: str = "dim"):
+        """Render a horizontal separator"""
+        width = self.console.width
+        self.console.print(char * width, style=style)
+
+
+class ProgressRenderer:
+    """Renderer for progress indicators"""
+    
+    def __init__(self, console: Console):
+        self.console = console
+    
+    def show_spinner(self, message: str = "Processing...", spinner: str = "dots"):
+        """Show a spinner with message"""
+        return self.console.status(f"[color(#2FCACE)]{message}[/color(#2FCACE)]", spinner=spinner)
+    
+    def show_progress_bar(self, total: int, description: str = "Progress"):
+        """Show a progress bar"""
+        from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+        
+        return Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            console=self.console
+        )