tzamuncode 0.1.0__py3-none-any.whl

tzamuncode/__init__.py

@@ -0,0 +1,10 @@
+"""
+TzamunCode - AI Coding Assistant
+
+Privacy-first AI coding assistant powered by local models.
+Built by Tzamun Arabia IT Co. 🇸🇦
+"""
+
+__version__ = "0.1.0"
+__author__ = "Tzamun Arabia IT Co."
+__email__ = "info@tzamun.com"

tzamuncode/agents/__init__.py

@@ -0,0 +1 @@
+"""Agentic AI module for TzamunCode"""

tzamuncode/agents/coder.py

@@ -0,0 +1,144 @@
+"""
+Agentic Coder - Advanced AI coding agent with file access and tool calling
+"""
+
+from typing import List, Dict, Optional, Any
+from pathlib import Path
+import json
+
+from langchain.agents import initialize_agent, Tool, AgentType
+from langchain.memory import ConversationBufferMemory
+from langchain_community.llms import Ollama
+
+from ..utils.file_ops import FileManager
+from ..utils.project_scanner import ProjectScanner
+from .tools import create_tools
+
+
+class AgenticCoder:
+    """
+    Advanced AI coding agent with file access and autonomous capabilities.
+    
+    Similar to Claude Code, this agent can:
+    - Read and write files autonomously
+    - Scan project structure
+    - Edit multiple files
+    - Execute git operations
+    - Search codebase
+    - Plan multi-step tasks
+    """
+    
+    def __init__(
+        self,
+        model: str = "qwen2.5:32b",
+        base_url: str = "http://localhost:11434",
+        workspace: Optional[str] = None
+    ):
+        self.model = model
+        self.base_url = base_url
+        self.workspace = Path(workspace) if workspace else Path.cwd()
+        
+        # Initialize components
+        self.file_manager = FileManager()
+        self.project_scanner = ProjectScanner(self.workspace)
+        
+        # Initialize LLM
+        self.llm = Ollama(
+            model=model,
+            base_url=base_url,
+            temperature=0.7
+        )
+        
+        # Create tools
+        self.tools = create_tools(
+            file_manager=self.file_manager,
+            project_scanner=self.project_scanner,
+            workspace=self.workspace
+        )
+        
+        # Initialize memory
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+        
+        # Initialize agent
+        self.agent = initialize_agent(
+            tools=self.tools,
+            llm=self.llm,
+            agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
+            verbose=True,
+            memory=self.memory,
+            handle_parsing_errors=True,
+            max_iterations=10
+        )
+    
+    def execute(self, instruction: str) -> Dict[str, Any]:
+        """
+        Execute an instruction using the agentic AI.
+        
+        The agent will autonomously:
+        - Scan project if needed
+        - Read relevant files
+        - Plan the changes
+        - Edit multiple files
+        - Provide summary
+        
+        Args:
+            instruction: What to do (e.g., "Add authentication to this Flask app")
+        
+        Returns:
+            Dict with result, files_changed, and summary
+        """
+        # Add context about workspace
+        context = f"""You are working in: {self.workspace}
+
+Available tools:
+- read_file: Read any file in the project
+- write_file: Write/create files
+- list_files: List files in directories
+- search_code: Search for code patterns
+- git_status: Check git status
+- scan_project: Understand project structure
+
+Instruction: {instruction}
+
+Think step by step:
+1. Understand what needs to be done
+2. Scan project structure if needed
+3. Read relevant files
+4. Plan the changes
+5. Make the changes
+6. Summarize what was done
+"""
+        
+        try:
+            result = self.agent.run(context)
+            
+            return {
+                "success": True,
+                "result": result,
+                "workspace": str(self.workspace)
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "workspace": str(self.workspace)
+            }
+    
+    def chat(self, message: str) -> str:
+        """
+        Chat with the agent while maintaining context.
+        
+        Args:
+            message: User message
+        
+        Returns:
+            Agent response
+        """
+        return self.agent.run(message)
+    
+    def reset_memory(self):
+        """Reset conversation memory"""
+        self.memory.clear()

tzamuncode/agents/tools.py

@@ -0,0 +1,159 @@
+"""
+Tool definitions for the agentic coder
+"""
+
+from langchain.tools import Tool
+from pathlib import Path
+from typing import List
+import subprocess
+import os
+
+from ..utils.file_ops import FileManager
+from ..utils.project_scanner import ProjectScanner
+
+
+def create_tools(
+    file_manager: FileManager,
+    project_scanner: ProjectScanner,
+    workspace: Path
+) -> List[Tool]:
+    """Create tools for the agent"""
+    
+    def read_file_tool(file_path: str) -> str:
+        """Read a file from the project"""
+        try:
+            full_path = workspace / file_path
+            return file_manager.read_file(str(full_path))
+        except Exception as e:
+            return f"Error reading file: {e}"
+    
+    def write_file_tool(args: str) -> str:
+        """
+        Write content to a file.
+        Args should be: file_path|||content
+        """
+        try:
+            parts = args.split("|||", 1)
+            if len(parts) != 2:
+                return "Error: Use format 'file_path|||content'"
+            
+            file_path, content = parts
+            full_path = workspace / file_path.strip()
+            file_manager.write_file(str(full_path), content.strip())
+            return f"Successfully wrote to {file_path}"
+        except Exception as e:
+            return f"Error writing file: {e}"
+    
+    def list_files_tool(directory: str = ".") -> str:
+        """List files in a directory"""
+        try:
+            dir_path = workspace / directory
+            files = file_manager.list_files(str(dir_path))
+            return "\n".join(files[:50])  # Limit to 50 files
+        except Exception as e:
+            return f"Error listing files: {e}"
+    
+    def search_code_tool(pattern: str) -> str:
+        """Search for code pattern in project"""
+        try:
+            result = subprocess.run(
+                ["grep", "-r", "-n", pattern, str(workspace)],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            output = result.stdout[:2000]  # Limit output
+            return output if output else "No matches found"
+        except Exception as e:
+            return f"Error searching: {e}"
+    
+    def git_status_tool(_: str = "") -> str:
+        """Check git status"""
+        try:
+            result = subprocess.run(
+                ["git", "status", "--short"],
+                cwd=workspace,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.stdout if result.stdout else "No changes"
+        except Exception as e:
+            return f"Error checking git: {e}"
+    
+    def scan_project_tool(_: str = "") -> str:
+        """Scan and understand project structure"""
+        try:
+            structure = project_scanner.scan()
+            return f"""Project Structure:
+Files: {structure['total_files']}
+Directories: {structure['total_dirs']}
+Languages: {', '.join(structure['languages'])}
+
+Key files:
+{chr(10).join(structure['key_files'][:10])}
+"""
+        except Exception as e:
+            return f"Error scanning project: {e}"
+    
+    def execute_command_tool(command: str) -> str:
+        """Execute a shell command (use with caution)"""
+        try:
+            # Whitelist safe commands
+            safe_commands = ['ls', 'pwd', 'cat', 'grep', 'find', 'git']
+            cmd_parts = command.split()
+            if not cmd_parts or cmd_parts[0] not in safe_commands:
+                return f"Error: Command '{cmd_parts[0] if cmd_parts else 'empty'}' not allowed"
+            
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=workspace,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            return result.stdout[:1000]  # Limit output
+        except Exception as e:
+            return f"Error executing command: {e}"
+    
+    # Create tool list
+    tools = [
+        Tool(
+            name="read_file",
+            func=read_file_tool,
+            description="Read a file from the project. Input: file path relative to project root"
+        ),
+        Tool(
+            name="write_file",
+            func=write_file_tool,
+            description="Write content to a file. Input: 'file_path|||content' (use ||| as separator)"
+        ),
+        Tool(
+            name="list_files",
+            func=list_files_tool,
+            description="List files in a directory. Input: directory path (default: current directory)"
+        ),
+        Tool(
+            name="search_code",
+            func=search_code_tool,
+            description="Search for a pattern in the codebase. Input: search pattern"
+        ),
+        Tool(
+            name="git_status",
+            func=git_status_tool,
+            description="Check git status. Input: empty string"
+        ),
+        Tool(
+            name="scan_project",
+            func=scan_project_tool,
+            description="Scan and understand project structure. Input: empty string"
+        ),
+        Tool(
+            name="execute_command",
+            func=execute_command_tool,
+            description="Execute a safe shell command. Input: command to execute"
+        ),
+    ]
+    
+    return tools

tzamuncode/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication module for TzamunCode"""

tzamuncode/auth/auth_manager.py

@@ -0,0 +1,159 @@
+"""
+Authentication Manager for TzamunCode
+Supports username/password and API key authentication with TzamunAI
+"""
+
+import requests
+import json
+from pathlib import Path
+from typing import Optional, Dict
+import hashlib
+from datetime import datetime, timedelta
+
+
+class AuthManager:
+    """Manage authentication for TzamunCode CLI"""
+    
+    CONFIG_DIR = Path.home() / ".tzamuncode"
+    CONFIG_FILE = CONFIG_DIR / "auth.json"
+    TZAMUN_API_BASE = "http://192.168.1.141:3008"  # Local Tzamun backend
+    
+    def __init__(self):
+        self.CONFIG_DIR.mkdir(exist_ok=True)
+        self.auth_data = self.load_auth()
+    
+    def load_auth(self) -> Dict:
+        """Load authentication data from config file"""
+        if self.CONFIG_FILE.exists():
+            try:
+                with open(self.CONFIG_FILE, 'r') as f:
+                    return json.load(f)
+            except:
+                return {}
+        return {}
+    
+    def save_auth(self, auth_data: Dict):
+        """Save authentication data to config file"""
+        with open(self.CONFIG_FILE, 'w') as f:
+            json.dump(auth_data, f, indent=2)
+        # Secure the file (only owner can read/write)
+        self.CONFIG_FILE.chmod(0o600)
+    
+    def is_authenticated(self) -> bool:
+        """Check if user is authenticated"""
+        if not self.auth_data:
+            return False
+        
+        # Check if token is expired
+        if 'expires_at' in self.auth_data:
+            expires_at = datetime.fromisoformat(self.auth_data['expires_at'])
+            if datetime.now() > expires_at:
+                return False
+        
+        return 'api_key' in self.auth_data or 'token' in self.auth_data
+    
+    def login_with_credentials(self, username: str, password: str) -> bool:
+        """
+        Login with username and password
+        
+        Args:
+            username: TzamunAI username
+            password: TzamunAI password
+        
+        Returns:
+            True if login successful
+        """
+        try:
+            # Call TzamunAI login API
+            response = requests.post(
+                f"{self.TZAMUN_API_BASE}/api/auth/login",
+                json={
+                    "username": username,
+                    "password": password
+                },
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                
+                # Save auth token
+                self.auth_data = {
+                    'type': 'credentials',
+                    'username': username,
+                    'token': data.get('token'),
+                    'expires_at': (datetime.now() + timedelta(days=30)).isoformat()
+                }
+                self.save_auth(self.auth_data)
+                return True
+            
+            return False
+            
+        except Exception as e:
+            print(f"Login error: {e}")
+            return False
+    
+    def login_with_api_key(self, api_key: str) -> bool:
+        """
+        Login with TzamunAI API key
+        
+        Args:
+            api_key: TzamunAI API key (from TCHub)
+        
+        Returns:
+            True if API key is valid
+        """
+        try:
+            # Validate API key with TzamunAI
+            response = requests.get(
+                f"{self.TZAMUN_API_BASE}/api/v1/tchub/validate",
+                headers={
+                    'X-API-Key': api_key
+                },
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                # Save API key
+                self.auth_data = {
+                    'type': 'api_key',
+                    'api_key': api_key,
+                    'validated_at': datetime.now().isoformat()
+                }
+                self.save_auth(self.auth_data)
+                return True
+            
+            return False
+            
+        except Exception as e:
+            print(f"API key validation error: {e}")
+            return False
+    
+    def logout(self):
+        """Logout and clear authentication data"""
+        self.auth_data = {}
+        if self.CONFIG_FILE.exists():
+            self.CONFIG_FILE.unlink()
+    
+    def get_auth_header(self) -> Dict[str, str]:
+        """Get authentication header for API requests"""
+        if not self.is_authenticated():
+            return {}
+        
+        if self.auth_data.get('type') == 'api_key':
+            return {'X-API-Key': self.auth_data['api_key']}
+        elif self.auth_data.get('type') == 'credentials':
+            return {'Authorization': f"Bearer {self.auth_data['token']}"}
+        
+        return {}
+    
+    def get_user_info(self) -> Dict:
+        """Get current user information"""
+        if not self.is_authenticated():
+            return {}
+        
+        return {
+            'type': self.auth_data.get('type'),
+            'username': self.auth_data.get('username', 'API Key User'),
+            'authenticated': True
+        }

tzamuncode/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI module for TzamunCode"""

tzamuncode/cli/agentic_commands.py

@@ -0,0 +1,131 @@
+"""
+Agentic commands - Advanced AI operations with autonomous file access
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+from rich.prompt import Confirm
+from rich.live import Live
+from rich.status import Status
+from typing import Optional
+import sys
+
+from ..agents.coder import AgenticCoder
+
+console = Console()
+
+
+def agentic_command(
+    instruction: str,
+    model: str = "qwen2.5:32b",
+    workspace: Optional[str] = None,
+    auto_apply: bool = False
+):
+    """
+    Execute an instruction using agentic AI with autonomous file access.
+    
+    This is similar to Claude Code - the AI can:
+    - Scan your project
+    - Read files autonomously
+    - Write/edit multiple files
+    - Execute git operations
+    - Plan multi-step tasks
+    
+    Args:
+        instruction: What to do (e.g., "Add authentication to this Flask app")
+        model: Model to use
+        workspace: Project directory (default: current directory)
+        auto_apply: Apply changes without confirmation
+    """
+    console.print(f"\n[bold blue]TzamunCode Agentic Mode[/bold blue]")
+    console.print(f"[dim]Model: {model}[/dim]")
+    console.print(f"[dim]Workspace: {workspace or 'current directory'}[/dim]\n")
+    
+    console.print(Panel(
+        f"[bold]Instruction:[/bold]\n{instruction}\n\n"
+        "[dim]The AI will autonomously:\n"
+        "• Scan project structure\n"
+        "• Read relevant files\n"
+        "• Plan changes\n"
+        "• Edit multiple files\n"
+        "• Provide summary[/dim]",
+        border_style="blue"
+    ))
+    
+    if not auto_apply:
+        if not Confirm.ask("\n[bold]Allow AI to access and modify files?[/bold]"):
+            console.print("[dim]Cancelled[/dim]")
+            return
+    
+    # Initialize agentic coder
+    with console.status("[bold blue]Initializing AI agent...", spinner="dots"):
+        try:
+            agent = AgenticCoder(
+                model=model,
+                workspace=workspace
+            )
+        except Exception as e:
+            console.print(f"[bold red]Error:[/bold red] Failed to initialize agent: {e}")
+            return
+    
+    console.print("[bold green]✓[/bold green] Agent initialized\n")
+    
+    # Execute instruction
+    console.print("[bold blue]AI is working...[/bold blue]\n")
+    
+    try:
+        with Live(console=console, refresh_per_second=4) as live:
+            result = agent.execute(instruction)
+        
+        if result['success']:
+            console.print("\n[bold green]✓ Task completed![/bold green]\n")
+            console.print(Panel(
+                Markdown(result['result']),
+                title="[bold blue]Summary[/bold blue]",
+                border_style="green"
+            ))
+        else:
+            console.print(f"\n[bold red]✗ Error:[/bold red] {result.get('error', 'Unknown error')}")
+            
+    except KeyboardInterrupt:
+        console.print("\n[dim]Interrupted by user[/dim]")
+    except Exception as e:
+        console.print(f"\n[bold red]Error:[/bold red] {e}")
+
+
+def project_command(workspace: Optional[str] = None):
+    """
+    Analyze and understand the project structure.
+    
+    Args:
+        workspace: Project directory (default: current directory)
+    """
+    from ..utils.project_scanner import ProjectScanner
+    from pathlib import Path
+    
+    workspace_path = Path(workspace) if workspace else Path.cwd()
+    
+    console.print(f"\n[bold blue]Scanning Project:[/bold blue] {workspace_path}\n")
+    
+    with console.status("[bold blue]Analyzing project...", spinner="dots"):
+        scanner = ProjectScanner(workspace_path)
+        structure = scanner.scan()
+        project_type = scanner.get_project_type()
+    
+    # Display results
+    console.print(Panel.fit(
+        f"""[bold]Project Analysis[/bold]
+
+[bold cyan]Type:[/bold cyan] {project_type}
+[bold cyan]Total Files:[/bold cyan] {structure['total_files']}
+[bold cyan]Total Directories:[/bold cyan] {structure['total_dirs']}
+[bold cyan]Languages:[/bold cyan] {', '.join(structure['languages']) if structure['languages'] else 'None detected'}
+
+[bold]Key Files:[/bold]
+{chr(10).join('  • ' + f for f in structure['key_files'][:15])}
+{f"  ... and {len(structure['key_files']) - 15} more" if len(structure['key_files']) > 15 else ""}
+""",
+        border_style="blue",
+        title="[bold blue]Project Structure[/bold blue]"
+    ))