tzamuncode 0.1.0__py3-none-any.whl

tzamuncode/cli/auth_commands.py

@@ -0,0 +1,125 @@
+"""
+Authentication commands for TzamunCode CLI
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+import getpass
+
+from ..auth.auth_manager import AuthManager
+
+console = Console()
+
+
+def login_command():
+    """Interactive login command"""
+    auth = AuthManager()
+    
+    # Check if already logged in
+    if auth.is_authenticated():
+        user_info = auth.get_user_info()
+        console.print(f"\n[yellow]Already logged in as:[/yellow] [cyan]{user_info['username']}[/cyan]")
+        
+        if not Confirm.ask("\n[bold]Logout and login again?[/bold]"):
+            return
+        
+        auth.logout()
+        console.print("[dim]Logged out[/dim]\n")
+    
+    # Show login options
+    console.print(Panel.fit(
+        """[bold cyan]TzamunCode Authentication[/bold cyan]
+
+Choose login method:
+[bold]1.[/bold] Username & Password (TzamunAI account)
+[bold]2.[/bold] API Key (from TzamunAI TCHub)
+""",
+        border_style="blue",
+        title="[bold blue]Login[/bold blue]"
+    ))
+    
+    choice = Prompt.ask("\n[bold]Select option[/bold]", choices=["1", "2"], default="2")
+    
+    if choice == "1":
+        # Username/Password login
+        console.print("\n[bold blue]Login with TzamunAI Account[/bold blue]\n")
+        
+        username = Prompt.ask("[bold]Username[/bold]")
+        password = getpass.getpass("Password: ")
+        
+        console.print("\n[dim]Authenticating...[/dim]")
+        
+        if auth.login_with_credentials(username, password):
+            console.print(f"\n[bold green]✓ Successfully logged in as {username}![/bold green]\n")
+        else:
+            console.print("\n[bold red]✗ Login failed. Please check your credentials.[/bold red]\n")
+    
+    else:
+        # API Key login
+        console.print("\n[bold blue]Login with API Key[/bold blue]\n")
+        console.print("[dim]Get your API key from: https://app.tzamun.ai/admin (API Config tab)[/dim]\n")
+        
+        api_key = Prompt.ask("[bold]API Key[/bold]", password=True)
+        
+        console.print("\n[dim]Validating API key...[/dim]")
+        
+        if auth.login_with_api_key(api_key):
+            console.print("\n[bold green]✓ Successfully authenticated with API key![/bold green]\n")
+        else:
+            console.print("\n[bold red]✗ Invalid API key. Please check and try again.[/bold red]\n")
+
+
+def logout_command():
+    """Logout command"""
+    auth = AuthManager()
+    
+    if not auth.is_authenticated():
+        console.print("\n[yellow]Not logged in[/yellow]\n")
+        return
+    
+    user_info = auth.get_user_info()
+    
+    if Confirm.ask(f"\n[bold]Logout from {user_info['username']}?[/bold]"):
+        auth.logout()
+        console.print("\n[bold green]✓ Logged out successfully[/bold green]\n")
+
+
+def whoami_command():
+    """Show current user info"""
+    auth = AuthManager()
+    
+    if not auth.is_authenticated():
+        console.print("\n[yellow]Not logged in[/yellow]")
+        console.print("[dim]Run 'tzamuncode login' to authenticate[/dim]\n")
+        return
+    
+    user_info = auth.get_user_info()
+    
+    table = Table(title="Current User", border_style="blue")
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="yellow")
+    
+    table.add_row("Status", "✓ Authenticated")
+    table.add_row("Type", user_info['type'].replace('_', ' ').title())
+    table.add_row("User", user_info['username'])
+    
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def require_auth(func):
+    """Decorator to require authentication before running a command"""
+    def wrapper(*args, **kwargs):
+        auth = AuthManager()
+        
+        if not auth.is_authenticated():
+            console.print("\n[bold red]✗ Authentication required[/bold red]")
+            console.print("[dim]Run 'tzamuncode login' to authenticate[/dim]\n")
+            return
+        
+        return func(*args, **kwargs)
+    
+    return wrapper

tzamuncode/cli/commands.py

@@ -0,0 +1,203 @@
+"""
+Command implementations for TzamunCode CLI
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+from rich.prompt import Prompt, Confirm
+from rich.syntax import Syntax
+from rich.live import Live
+from rich.spinner import Spinner
+from typing import Optional
+import sys
+
+from ..models.ollama import OllamaClient
+from ..utils.file_ops import FileManager
+
+console = Console()
+
+def chat_command(model: str, system: Optional[str] = None):
+    """Interactive chat with AI"""
+    client = OllamaClient(model=model)
+    
+    console.print(Panel.fit(
+        f"[bold blue]TzamunCode Chat[/bold blue]\n\n"
+        f"Model: [cyan]{model}[/cyan]\n"
+        f"Type [bold]'exit'[/bold] or [bold]'quit'[/bold] to end the session",
+        border_style="blue"
+    ))
+    
+    conversation_history = []
+    
+    if system:
+        conversation_history.append({"role": "system", "content": system})
+    
+    while True:
+        try:
+            user_input = Prompt.ask("\n[bold green]You[/bold green]")
+            
+            if user_input.lower() in ['exit', 'quit', 'q']:
+                console.print("[dim]Goodbye! 👋[/dim]")
+                break
+            
+            conversation_history.append({"role": "user", "content": user_input})
+            
+            console.print("\n[bold blue]TzamunCode[/bold blue]:", end=" ")
+            
+            # Stream response
+            response = ""
+            for chunk in client.chat_stream(conversation_history):
+                response += chunk
+                console.print(chunk, end="")
+            
+            console.print()  # New line after response
+            
+            conversation_history.append({"role": "assistant", "content": response})
+            
+        except KeyboardInterrupt:
+            console.print("\n[dim]Interrupted. Goodbye! 👋[/dim]")
+            break
+        except Exception as e:
+            console.print(f"\n[bold red]Error:[/bold red] {e}")
+
+def generate_command(prompt: str, model: str, output: Optional[str] = None):
+    """Generate code based on prompt"""
+    client = OllamaClient(model=model)
+    file_manager = FileManager()
+    
+    console.print(f"\n[bold blue]Generating:[/bold blue] {prompt}")
+    console.print(f"[dim]Model: {model}[/dim]\n")
+    
+    # Create generation prompt
+    full_prompt = f"""Generate code for: {prompt}
+
+Requirements:
+- Write clean, well-documented code
+- Include error handling
+- Follow best practices
+- Add comments explaining complex logic
+
+Generate the complete, working code:"""
+    
+    with console.status("[bold blue]Generating code...", spinner="dots"):
+        response = client.generate(full_prompt)
+    
+    # Extract code from response
+    code = response.strip()
+    
+    # Display generated code
+    console.print("\n[bold green]Generated Code:[/bold green]\n")
+    
+    # Try to detect language for syntax highlighting
+    language = "python"  # Default
+    if output:
+        if output.endswith('.js'):
+            language = "javascript"
+        elif output.endswith('.go'):
+            language = "go"
+        elif output.endswith('.rs'):
+            language = "rust"
+    
+    syntax = Syntax(code, language, theme="monokai", line_numbers=True)
+    console.print(syntax)
+    
+    # Save to file if output specified
+    if output:
+        if Confirm.ask(f"\n[bold]Save to {output}?[/bold]"):
+            file_manager.write_file(output, code)
+            console.print(f"[bold green]✓[/bold green] Saved to {output}")
+    else:
+        if Confirm.ask("\n[bold]Save to file?[/bold]"):
+            filename = Prompt.ask("Filename")
+            file_manager.write_file(filename, code)
+            console.print(f"[bold green]✓[/bold green] Saved to {filename}")
+
+def edit_command(file_path: str, instruction: str, model: str, apply: bool = False):
+    """Edit a file using AI"""
+    client = OllamaClient(model=model)
+    file_manager = FileManager()
+    
+    # Read current file
+    try:
+        current_content = file_manager.read_file(file_path)
+    except FileNotFoundError:
+        console.print(f"[bold red]Error:[/bold red] File not found: {file_path}")
+        return
+    
+    console.print(f"\n[bold blue]Editing:[/bold blue] {file_path}")
+    console.print(f"[bold blue]Instruction:[/bold blue] {instruction}")
+    console.print(f"[dim]Model: {model}[/dim]\n")
+    
+    # Create edit prompt
+    edit_prompt = f"""You are editing the file: {file_path}
+
+Current content:
+```
+{current_content}
+```
+
+Instruction: {instruction}
+
+Provide the complete modified file content. Only output the code, no explanations:"""
+    
+    with console.status("[bold blue]Generating changes...", spinner="dots"):
+        new_content = client.generate(edit_prompt)
+    
+    # Show diff
+    diff = file_manager.show_diff(file_path, new_content)
+    
+    if diff:
+        console.print("\n[bold yellow]Changes:[/bold yellow]\n")
+        console.print(diff)
+        
+        # Apply changes
+        if apply or Confirm.ask("\n[bold]Apply these changes?[/bold]"):
+            file_manager.write_file(file_path, new_content)
+            console.print(f"[bold green]✓[/bold green] Changes applied to {file_path}")
+        else:
+            console.print("[dim]Changes not applied[/dim]")
+    else:
+        console.print("[dim]No changes needed[/dim]")
+
+def explain_command(file_path: str, model: str, detailed: bool = False):
+    """Explain code in a file"""
+    client = OllamaClient(model=model)
+    file_manager = FileManager()
+    
+    # Read file
+    try:
+        content = file_manager.read_file(file_path)
+    except FileNotFoundError:
+        console.print(f"[bold red]Error:[/bold red] File not found: {file_path}")
+        return
+    
+    console.print(f"\n[bold blue]Explaining:[/bold blue] {file_path}")
+    console.print(f"[dim]Model: {model}[/dim]\n")
+    
+    # Create explanation prompt
+    detail_level = "detailed" if detailed else "concise"
+    explain_prompt = f"""Explain this code in a {detail_level} way:
+
+File: {file_path}
+```
+{content}
+```
+
+Provide a clear explanation covering:
+- What the code does
+- Key functions/classes
+- Important logic
+- Potential improvements (if detailed)
+
+Explanation:"""
+    
+    with console.status("[bold blue]Analyzing code...", spinner="dots"):
+        explanation = client.generate(explain_prompt)
+    
+    # Display explanation
+    console.print(Panel(
+        Markdown(explanation),
+        title=f"[bold blue]Explanation: {file_path}[/bold blue]",
+        border_style="blue"
+    ))

tzamuncode/cli/enhanced_chat.py

@@ -0,0 +1,312 @@
+"""
+Enhanced interactive chat with beautiful UI and slash commands
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Prompt
+from rich.markdown import Markdown
+from rich.layout import Layout
+from rich.live import Live
+from rich.text import Text
+from typing import Optional, List, Dict
+import sys
+
+from ..models.ollama import OllamaClient
+
+console = Console()
+
+
+class EnhancedChat:
+    """Enhanced chat interface with Claude Code-like UI"""
+    
+    ASCII_LOGO = """
+╔╦╗╔═╗╔═╗╔╦╗╦ ╦╔╗╔╔═╗╔═╗╔╦╗╔═╗
+ ║ ╔═╝╠═╣║║║║ ║║║║║  ║ ║ ║║╣ 
+ ╩ ╚═╝╩ ╩╩ ╩╚═╝╝╚╝╚═╝╚═╝═╩╝╚═╝
+    """
+    
+    SLASH_COMMANDS = {
+        '/help': 'Show available commands',
+        '/models': 'List and switch models',
+        '/settings': 'Show settings',
+        '/clear': 'Clear conversation history',
+        '/save': 'Save conversation',
+        '/load': 'Load conversation',
+        '/exit': 'Exit chat',
+        '/quit': 'Exit chat',
+    }
+    
+    def __init__(self, model: str = "qwen2.5:32b", system: Optional[str] = None):
+        self.model = model
+        self.system = system
+        self.client = OllamaClient(model=model)
+        self.conversation_history = []
+        self.available_models = []
+        self.settings = {
+            'temperature': 0.7,
+            'streaming': True,
+            'show_thinking': False,
+        }
+        
+        # Load available models
+        try:
+            self.available_models = self.client.list_models()
+        except:
+            self.available_models = [model]
+    
+    
+    def show_command_menu(self):
+        """Show command menu when user types '/'"""
+        console.print()
+        
+        # Professional command menu
+        table = Table(
+            title="[bold cyan]Available Commands[/bold cyan]",
+            border_style="blue",
+            show_header=True,
+            header_style="bold white on blue",
+            title_style="bold cyan"
+        )
+        table.add_column("Command", style="bold cyan", no_wrap=True, width=20)
+        table.add_column("Description", style="white")
+        
+        for cmd, desc in self.SLASH_COMMANDS.items():
+            table.add_row(cmd, desc)
+        
+        console.print(table)
+        console.print()
+    
+    def show_help(self):
+        """Show help with all commands"""
+        self.show_command_menu()
+    
+    def show_models(self) -> Optional[str]:
+        """Show model selector and return selected model"""
+        console.print()
+        
+        # Professional model selection table
+        table = Table(
+            title="[bold cyan]Available Models[/bold cyan]",
+            border_style="blue",
+            show_header=True,
+            header_style="bold white on blue"
+        )
+        table.add_column("#", style="dim", width=4)
+        table.add_column("Model Name", style="cyan")
+        table.add_column("Status", style="green", width=12)
+        
+        for idx, model_name in enumerate(self.available_models, 1):
+            status = "✓ Active" if model_name == self.model else ""
+            table.add_row(str(idx), model_name, status)
+        
+        console.print(table)
+        console.print()
+        
+        choice = Prompt.ask(
+            "[bold blue]Select model number[/bold blue] [dim](or Enter to cancel)[/dim]",
+            default=""
+        )
+        
+        if choice and choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(self.available_models):
+                new_model = self.available_models[idx]
+                self.model = new_model
+                self.client = OllamaClient(model=new_model)
+                console.print(f"\n[bold green]✓[/bold green] Switched to [cyan]{new_model}[/cyan]\n")
+                return new_model
+        
+        console.print("[dim]Cancelled[/dim]\n")
+        return None
+    
+    def show_settings(self):
+        """Show current settings"""
+        from .. import __version__
+        
+        console.print()
+        
+        # Professional settings panel
+        table = Table(
+            title="[bold cyan]Current Settings[/bold cyan]",
+            border_style="blue",
+            show_header=True,
+            header_style="bold white on blue"
+        )
+        table.add_column("Setting", style="bold cyan", width=20)
+        table.add_column("Value", style="yellow")
+        
+        table.add_row("Version", __version__)
+        table.add_row("Company", "Tzamun Arabia IT Co. 🇸🇦")
+        table.add_row("Model", self.model)
+        table.add_row("Available Models", str(len(self.available_models)))
+        table.add_row("Temperature", str(self.settings['temperature']))
+        table.add_row("Streaming", "✓ Enabled" if self.settings['streaming'] else "✗ Disabled")
+        
+        console.print(table)
+        console.print()
+    
+    def handle_slash_command(self, command: str) -> bool:
+        """
+        Handle slash commands
+        
+        Returns:
+            True if should continue chat, False if should exit
+        """
+        command = command.lower().strip()
+        
+        if command in ['/exit', '/quit']:
+            return False
+        
+        elif command == '/help':
+            self.show_help()
+        
+        elif command == '/models':
+            self.show_models()
+        
+        elif command == '/settings':
+            self.show_settings()
+        
+        elif command == '/clear':
+            self.conversation_history = []
+            self.show_header()
+            console.print("[bold green]✓[/bold green] Conversation cleared\n")
+        
+        elif command == '/save':
+            console.print("[dim]Save feature coming soon...[/dim]\n")
+        
+        elif command == '/load':
+            console.print("[dim]Load feature coming soon...[/dim]\n")
+        
+        else:
+            console.print(f"[bold red]Unknown command:[/bold red] {command}")
+            console.print("[dim]Type '/help' to see available commands[/dim]\n")
+        
+        return True
+    
+    def format_user_message(self, message: str):
+        """Format user message"""
+        console.print(f"\n[bold green]You[/bold green] [dim]›[/dim] {message}")
+    
+    def format_ai_response(self, response: str):
+        """Format AI response"""
+        console.print(f"\n[bold blue]TzamunCode[/bold blue] [dim]›[/dim]")
+        
+        # Try to render as markdown if it looks like code
+        if '```' in response or response.strip().startswith('#'):
+            console.print(Markdown(response))
+        else:
+            console.print(response)
+        
+        console.print()
+    
+    def run(self):
+        """Run the enhanced chat interface"""
+        # Professional header with complete information
+        from .. import __version__
+        
+        console.print()
+        console.print("─" * console.width, style="dim")
+        console.print()
+        
+        # ASCII Logo
+        console.print("[bold cyan]╔╦╗╔═╗╔═╗╔╦╗╦ ╦╔╗╔╔═╗╔═╗╔╦╗╔═╗[/bold cyan]")
+        console.print("[bold cyan] ║ ╔═╝╠═╣║║║║ ║║║║║  ║ ║ ║║╣[/bold cyan]")
+        console.print("[bold cyan] ╩ ╚═╝╩ ╩╩ ╩╚═╝╝╚╝╚═╝╚═╝═╩╝╚═╝[/bold cyan]")
+        
+        console.print()
+        
+        # Professional info panel
+        info_panel = Panel.fit(
+            f"""[bold]AI Coding Assistant[/bold]
+            
+[cyan]Version:[/cyan] {__version__}
+[cyan]Company:[/cyan] Tzamun Arabia IT Co. 🇸🇦
+[cyan]Model:[/cyan] {self.model}
+[cyan]Models Available:[/cyan] {len(self.available_models)}
+
+[dim]Type '/help' for commands • Type '?' for shortcuts[/dim]""",
+            border_style="blue",
+            padding=(0, 2)
+        )
+        console.print(info_panel)
+        console.print()
+        console.print("─" * console.width, style="dim")
+        console.print()
+        
+        # Add system message if provided
+        if self.system:
+            self.conversation_history.append({"role": "system", "content": self.system})
+        
+        while True:
+            try:
+                # Simple prompt
+                console.print()
+                user_input = Prompt.ask("[dim]›[/dim]", default="")
+                
+                if not user_input or not user_input.strip():
+                    continue
+                
+                # Check for exit commands
+                if user_input.lower() in ['exit', 'quit', 'q']:
+                    console.print("\n[dim]Goodbye! 👋[/dim]\n")
+                    break
+                
+                # Check if user just typed '/' - show command menu
+                if user_input.strip() == '/':
+                    self.show_command_menu()
+                    continue
+                
+                # Check for slash commands
+                if user_input.startswith('/'):
+                    should_continue = self.handle_slash_command(user_input)
+                    if not should_continue:
+                        console.print("\n[dim]Goodbye! 👋[/dim]\n")
+                        break
+                    continue
+                
+                # Format and show user message
+                self.format_user_message(user_input)
+                
+                # Add to conversation history
+                self.conversation_history.append({"role": "user", "content": user_input})
+                
+                # Get AI response
+                if self.settings['streaming']:
+                    # Stream response
+                    console.print(f"\n[bold blue]TzamunCode[/bold blue] [dim]›[/dim] ", end="")
+                    
+                    response = ""
+                    for chunk in self.client.chat_stream(self.conversation_history):
+                        response += chunk
+                        console.print(chunk, end="")
+                    
+                    console.print("\n")
+                else:
+                    # Non-streaming response
+                    with console.status("[bold blue]Thinking...", spinner="dots"):
+                        response = self.client.chat(self.conversation_history)
+                    
+                    self.format_ai_response(response)
+                
+                # Add to conversation history
+                self.conversation_history.append({"role": "assistant", "content": response})
+                
+            except KeyboardInterrupt:
+                console.print("\n\n[dim]Interrupted. Type 'exit' to quit or continue chatting.[/dim]\n")
+                continue
+            
+            except EOFError:
+                console.print("\n[dim]Goodbye! 👋[/dim]\n")
+                break
+            
+            except Exception as e:
+                console.print(f"\n[bold red]Error:[/bold red] {e}\n")
+                continue
+
+
+def enhanced_chat_command(model: str, system: Optional[str] = None):
+    """Run enhanced chat interface"""
+    chat = EnhancedChat(model=model, system=system)
+    chat.run()