samcode-cli 1.0.1__tar.gz → 1.0.3__tar.gz

samcode_cli-1.0.3/MANIFEST.in

@@ -0,0 +1 @@
+global-exclude .samcode/*

{samcode_cli-1.0.1 → samcode_cli-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: samcode-cli
-Version: 1.0.1
+Version: 1.0.3
 Summary: An autonomous AI coding agent that runs in your terminal.
 Author: Magra Houssem Eddine
 Description-Content-Type: text/markdown

samcode_cli-1.0.3/samcode.py

@@ -0,0 +1,1060 @@
+#!/usr/bin/env python3
+"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                          S A M C O D E   C L I                              ║
+║                   Autonomous Coding Agent v5.4                              ║
+║              Similar to Claude Code & GitHub Copilot Workspace              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+
+import os
+import sys
+import json
+import subprocess
+import re
+import time
+import urllib.parse
+import webbrowser
+from typing import List, Dict, Tuple, Optional, Any
+from pathlib import Path
+from dataclasses import dataclass
+from enum import Enum
+
+# Rich UI Components
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.prompt import Prompt, Confirm
+from rich.columns import Columns
+from rich.text import Text
+
+# Interactive Selection & Autocomplete
+try:
+    import questionary
+    from questionary import Choice
+    from prompt_toolkit import prompt as pt_prompt
+    from prompt_toolkit.completion import WordCompleter
+    from prompt_toolkit.formatted_text import FormattedText
+    from prompt_toolkit.styles import Style
+    from prompt_toolkit.enums import EditingMode
+except ImportError:
+    subprocess.run([sys.executable, "-m", "pip", "install", "questionary", "-q"], capture_output=True)
+    import questionary
+    from questionary import Choice
+    from prompt_toolkit import prompt as pt_prompt
+    from prompt_toolkit.completion import WordCompleter
+    from prompt_toolkit.formatted_text import FormattedText
+    from prompt_toolkit.styles import Style
+    from prompt_toolkit.enums import EditingMode
+
+# HTTP Client
+try:
+    import requests
+except ImportError:
+    subprocess.run([sys.executable, "-m", "pip", "install", "requests", "-q"], capture_output=True)
+    import requests
+
+# Document Processing & Web Parsing Libraries Auto-Install
+LIBS_TO_INSTALL = {
+    'pdfplumber': 'pdfplumber', 'docx': 'python-docx', 'openpyxl': 'openpyxl',
+    'pptx': 'python-pptx', 'PIL': 'Pillow', 'bs4': 'beautifulsoup4'
+}
+for module, package in LIBS_TO_INSTALL.items():
+    try:
+        __import__(module)
+    except ImportError:
+        subprocess.run([sys.executable, "-m", "pip", "install", package, "-q"], capture_output=True)
+
+console = Console()
+
+menu_style = Style.from_dict({
+    'completion-menu': 'bg:#1e1e1e',
+    'completion-menu.completion': 'fg:#00d7d7 bg:#1e1e1e',
+    'completion-menu.completion.current': 'fg:#ffffff bg:#00af00 bold',
+})
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# KEYBOARD SHORTCUTS FOR PROMPT (Only custom ones)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from prompt_toolkit.key_binding import KeyBindings
+
+kb = KeyBindings()
+
+@kb.add('c-w')
+def _(event):
+    "Delete word backward (Ctrl+W)"
+    b = event.app.current_buffer
+    pos = b.document.find_start_of_previous_word()
+    if pos is not None:
+        b.delete_before_cursor(-pos)
+
+@kb.add('c-u')
+def _(event):
+    "Clear line backward (Ctrl+U)"
+    event.app.current_buffer.delete_before_cursor(event.app.current_buffer.cursor_position)
+
+@kb.add('c-k')
+def _(event):
+    "Delete to end of line (Ctrl+K)"
+    b = event.app.current_buffer
+    b.delete(len(b.text) - b.cursor_position)
+
+
+class DocumentReader:
+    @staticmethod
+    def extract_text(filepath: str) -> str:
+        ext = Path(filepath).suffix.lower()
+        try:
+            if ext == '.pdf':
+                import pdfplumber
+                text = []
+                with pdfplumber.open(filepath) as pdf:
+                    for page in pdf.pages:
+                        page_text = page.extract_text()
+                        if page_text: text.append(page_text)
+                return "\n".join(text) if text else "[No extractable text found in PDF]"
+            elif ext == '.docx':
+                import docx
+                doc = docx.Document(filepath)
+                paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+                for table in doc.tables:
+                    for row in table.rows:
+                        row_text = " | ".join([cell.text.strip() for cell in row.cells])
+                        paragraphs.append(row_text)
+                return "\n".join(paragraphs)
+            elif ext in ['.xlsx', '.xls']:
+                import openpyxl
+                wb = openpyxl.load_workbook(filepath, data_only=True)
+                text = []
+                for sheet in wb.sheetnames:
+                    text.append(f"\n--- Sheet: {sheet} ---")
+                    for row in wb[sheet].iter_rows(values_only=True):
+                        text.append(" | ".join([str(cell) if cell is not None else "" for cell in row]))
+                return "\n".join(text)
+            elif ext == '.pptx':
+                import pptx
+                prs = pptx.Presentation(filepath)
+                text = []
+                for i, slide in enumerate(prs.slides):
+                    text.append(f"\n--- Slide {i+1} ---")
+                    for shape in slide.shapes:
+                        if hasattr(shape, "text") and shape.text.strip():
+                            text.append(shape.text)
+                return "\n".join(text)
+            elif ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff']:
+                from PIL import Image
+                img = Image.open(filepath)
+                return f"[Image: {Path(filepath).name}]\nFormat: {img.format}\nDimensions: {img.size[0]}x{img.size[1]}\nMode: {img.mode}\n(Note: Visual content converted to metadata for text-only model compatibility)"
+            else:
+                with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                    return f.read()
+        except Exception as e:
+            return f"[Error extracting {filepath}: {str(e)}]"
+
+def search_web(query: str, max_results: int = 5) -> str:
+    try:
+        from bs4 import BeautifulSoup
+        session = requests.Session()
+        session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+            'Sec-Fetch-Dest': 'document',
+            'Sec-Fetch-Mode': 'navigate',
+            'Sec-Fetch-Site': 'none',
+            'Sec-Fetch-User': '?1',
+        })
+        url = f"https://html.duckduckgo.com/html/?q={urllib.parse.quote(query)}"
+        resp = session.get(url, timeout=10)
+        
+        if resp.status_code != 200:
+            return f"[SCRAPE_FAILED: Status {resp.status_code}]"
+        
+        soup = BeautifulSoup(resp.text, 'html.parser')
+        results = []
+        for a in soup.find_all('a', class_='result__snippet', limit=max_results):
+            text = a.get_text(strip=True)
+            if text: results.append(f"Result: {text}")
+        
+        if not results:
+            for div in soup.find_all('div', class_='result__body', limit=max_results):
+                snippet = div.find('a', class_='result__snippet')
+                if snippet: results.append(f"Result: {snippet.get_text(strip=True)}")
+                
+        if not results:
+            return "[SCRAPE_FAILED: No text found]"
+        return "\n---\n".join(results)
+    except Exception as e:
+        return f"[SCRAPE_FAILED: {str(e)}]"
+
+class CavemanMode(Enum):
+    OFF = 0; BASIC = 1; ULTRA = 2
+
+@dataclass
+class ProviderConfig:
+    name: str; base_url: str; models_url: str; default_model: str; auth_type: str; supports_vision: bool = False
+
+@dataclass
+class ModelInfo:
+    id: str; name: str; provider: str; context_window: int = 0
+
+class ProviderRegistry:
+    BUILT_IN_PROVIDERS = {
+        "openai": ProviderConfig("OpenAI", "https://api.openai.com/v1", "https://api.openai.com/v1/models", "gpt-4o", "bearer", True),
+        "anthropic": ProviderConfig("Anthropic", "https://api.anthropic.com/v1", "https://api.anthropic.com/v1/models", "claude-3-5-sonnet-20241022", "bearer", True),
+        "google": ProviderConfig("Google Gemini", "https://generativelanguage.googleapis.com/v1beta", "https://generativelanguage.googleapis.com/v1beta/models", "gemini-1.5-flash", "api_key", True),
+        "deepseek": ProviderConfig("DeepSeek", "https://api.deepseek.com/v1", "https://api.deepseek.com/v1/models", "deepseek-chat", "bearer", False),
+        "ollama": ProviderConfig("Ollama (Local)", "http://localhost:11434/v1", "http://localhost:11434/api/tags", "llama3.2", "none", False),
+        "groq": ProviderConfig("Groq", "https://api.groq.com/openai/v1", "https://api.groq.com/openai/v1/models", "llama-3.3-70b-versatile", "bearer", False),
+        "mistral": ProviderConfig("Mistral AI", "https://api.mistral.ai/v1", "https://api.mistral.ai/v1/models", "mistral-large-latest", "bearer", True),
+        "openrouter": ProviderConfig("OpenRouter", "https://openrouter.ai/api/v1", "https://openrouter.ai/api/v1/models", "anthropic/claude-3.5-sonnet", "bearer", True),
+        "qwen": ProviderConfig("Qwen (Alibaba)", "https://dashscope.aliyuncs.com/compatible-mode/v1", "https://dashscope.aliyuncs.com/compatible-mode/v1/models", "qwen-turbo", "bearer", True),
+        "custom": ProviderConfig("Custom Provider", "", "", "custom-model", "bearer", True)
+    }
+    def __init__(self): self.providers = self.BUILT_IN_PROVIDERS.copy()
+    def get_provider(self, name: str) -> Optional[ProviderConfig]: return self.providers.get(name.lower())
+    def list_providers(self) -> List[Tuple[str, ProviderConfig]]: return [(name, config) for name, config in self.providers.items()]
+
+class FileSystemManager:
+    def __init__(self, workspace_dir: str):
+        self.workspace_dir = workspace_dir
+        self.ignored_patterns = [".git", "__pycache__", "node_modules", ".venv", "venv", ".egg-info", "dist", "build", ".DS_Store", ".idea", ".vscode"]
+    def should_ignore(self, path: str) -> bool: return any(pattern in path for pattern in self.ignored_patterns)
+    def scan_workspace(self, max_files: int = 300) -> List[str]:
+        files = []
+        for root, dirs, filenames in os.walk(self.workspace_dir):
+            dirs[:] = [d for d in dirs if not self.should_ignore(os.path.join(root, d))]
+            for filename in filenames:
+                if self.should_ignore(filename): continue
+                rel_path = os.path.relpath(os.path.join(root, filename), self.workspace_dir)
+                files.append(rel_path)
+                if len(files) >= max_files: break
+            if len(files) >= max_files: break
+        return sorted(files)
+    def read_file(self, filepath: str) -> Optional[str]:
+        full_path = os.path.join(self.workspace_dir, filepath)
+        if not os.path.exists(full_path): return None
+        try:
+            with open(full_path, "r", encoding="utf-8") as f: return f.read()
+        except Exception: return None
+    def write_file(self, filepath: str, content: str) -> bool:
+        full_path = os.path.join(self.workspace_dir, filepath)
+        try:
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, "w", encoding="utf-8") as f: f.write(content)
+            return True
+        except Exception as e:
+            console.print(f"[red]Error writing {filepath}: {e}[/red]")
+            return False
+    def search_in_files(self, query: str) -> List[Dict]:
+        results = []
+        for root, dirs, files in os.walk(self.workspace_dir):
+            dirs[:] = [d for d in dirs if not self.should_ignore(os.path.join(root, d))]
+            for filename in files:
+                if self.should_ignore(filename): continue
+                full_path = os.path.join(root, filename)
+                try:
+                    with open(full_path, 'r', encoding='utf-8', errors='ignore') as f: content = f.read()
+                    if query.lower() in content.lower():
+                        lines = content.splitlines()
+                        matches = [(i+1, line.strip()) for i, line in enumerate(lines) if query.lower() in line.lower()][:3]
+                        results.append({'file': os.path.relpath(full_path, self.workspace_dir), 'matches': matches})
+                except Exception: continue
+        return results[:10]
+
+class CommandRunner:
+    def __init__(self, workspace_dir: str):
+        self.workspace_dir = workspace_dir
+        self.dangerous_commands = ["rm -rf /", "sudo rm -rf", "mkfs", "dd if="]
+    def is_dangerous(self, cmd: str) -> bool: return any(dangerous in cmd for dangerous in self.dangerous_commands)
+    def run(self, cmd: str, timeout: int = 120) -> Tuple[bool, str]:
+        try:
+            result = subprocess.run(cmd, shell=True, cwd=self.workspace_dir, capture_output=True, text=True, timeout=timeout)
+            output = result.stdout + (f"\n[STDERR]\n{result.stderr}" if result.stderr else "")
+            return result.returncode == 0, output
+        except subprocess.TimeoutExpired: return False, "Command timed out"
+        except Exception as e: return False, f"Error: {str(e)}"
+
+class GitManager:
+    def __init__(self, workspace_dir: str, console: Console):
+        self.workspace_dir = workspace_dir; self.console = console; self.git_dir = os.path.join(workspace_dir, ".git")
+    def is_git_installed(self) -> bool:
+        try: subprocess.run(["git", "--version"], capture_output=True, check=True); return True
+        except (subprocess.CalledProcessError, FileNotFoundError): return False
+    def is_repo(self) -> bool: return os.path.exists(self.git_dir)
+    def get_current_branch(self) -> str:
+        try: return subprocess.run(["git", "branch", "--show-current"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10).stdout.strip() or "main"
+        except Exception: return "main"
+    def get_remote_url(self) -> str:
+        try: return subprocess.run(["git", "remote", "get-url", "origin"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10).stdout.strip()
+        except Exception: return ""
+    def check_github_auth(self) -> Dict[str, Any]:
+        result = {"logged_in": False, "user": "", "method": ""}
+        try:
+            gh_result = subprocess.run(["gh", "auth", "status"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            if gh_result.returncode == 0:
+                result["logged_in"] = True; result["method"] = "GitHub CLI (gh)"
+                for line in gh_result.stdout.split("\n"):
+                    if "Logged in to" in line or "github.com" in line:
+                        parts = line.split()
+                        for i, part in enumerate(parts):
+                            if part == "as" and i + 1 < len(parts): result["user"] = parts[i + 1].strip("()"); break
+                return result
+        except FileNotFoundError: pass
+        try:
+            user_result = subprocess.run(["git", "config", "user.name"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            email_result = subprocess.run(["git", "config", "user.email"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            if user_result.stdout.strip():
+                result["logged_in"] = True; result["user"] = f"{user_result.stdout.strip()} <{email_result.stdout.strip()}>"; result["method"] = "Git credentials"
+        except Exception: pass
+        return result
+    def get_status(self) -> Dict[str, Any]:
+        if not self.is_repo(): return {"error": "Not a git repository"}
+        try:
+            status_result = subprocess.run(["git", "status", "--porcelain"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            lines = [l for l in status_result.stdout.strip().split("\n") if l]
+            staged, unstaged, untracked = [], [], []
+            for line in lines:
+                status_code, filepath = line[:2], line[3:].strip()
+                if status_code[0] != ' ' and status_code[0] != '?': staged.append({"file": filepath, "status": status_code[0]})
+                if status_code[1] != ' ' and status_code[1] != '?': unstaged.append({"file": filepath, "status": status_code[1]})
+                if status_code == '??': untracked.append(filepath)
+            return {"branch": self.get_current_branch(), "remote": self.get_remote_url(), "staged": staged, "unstaged": unstaged, "untracked": untracked, "has_changes": len(lines) > 0}
+        except Exception as e: return {"error": str(e)}
+    def get_diff(self, staged: bool = False) -> str:
+        if not self.is_repo(): return "Not a git repository"
+        try:
+            cmd = ["git", "diff", "--cached"] if staged else ["git", "diff"]
+            return subprocess.run(cmd, cwd=self.workspace_dir, capture_output=True, text=True, timeout=30).stdout or "No changes to show"
+        except Exception as e: return f"Error: {str(e)}"
+    def get_log(self, count: int = 10) -> str:
+        if not self.is_repo(): return "Not a git repository"
+        try: return subprocess.run(["git", "log", f"-{count}", "--format=%h %s (%an, %ar)"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10).stdout or "No commits yet"
+        except Exception as e: return f"Error: {str(e)}"
+    def get_branches(self) -> List[str]:
+        if not self.is_repo(): return []
+        try: return [b.strip().lstrip("* ") for b in subprocess.run(["git", "branch"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10).stdout.strip().split("\n") if b.strip()]
+        except Exception: return []
+    def init_repo(self) -> Tuple[bool, str]:
+        try:
+            subprocess.run(["git", "init"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10, check=True)
+            subprocess.run(["git", "checkout", "-b", "main"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            return True, "Repository initialized with 'main' branch"
+        except Exception as e: return False, f"Error initializing: {str(e)}"
+    def add_all(self) -> Tuple[bool, str]:
+        try: subprocess.run(["git", "add", "-A"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=30, check=True); return True, "All changes staged"
+        except Exception as e: return False, f"Error staging: {str(e)}"
+    def commit(self, message: str) -> Tuple[bool, str]:
+        try:
+            result = subprocess.run(["git", "commit", "-m", message], cwd=self.workspace_dir, capture_output=True, text=True, timeout=30)
+            return (True, result.stdout.strip()) if result.returncode == 0 else (False, result.stderr.strip() or "Nothing to commit")
+        except Exception as e: return False, f"Error committing: {str(e)}"
+    def add_remote(self, url: str) -> Tuple[bool, str]:
+        try:
+            subprocess.run(["git", "remote", "remove", "origin"], cwd=self.workspace_dir, capture_output=True, timeout=10)
+            subprocess.run(["git", "remote", "add", "origin", url], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10, check=True)
+            return True, f"Remote 'origin' set to {url}"
+        except Exception as e: return False, f"Error adding remote: {str(e)}"
+    def push(self, branch: str = None, force: bool = False) -> Tuple[bool, str]:
+        if not branch: branch = self.get_current_branch()
+        try:
+            cmd = ["git", "push", "-u", "origin", branch]
+            if force: cmd.insert(2, "--force")
+            result = subprocess.run(cmd, cwd=self.workspace_dir, capture_output=True, text=True, timeout=120)
+            return (True, result.stdout.strip()) if result.returncode == 0 else (False, result.stderr.strip())
+        except Exception as e: return False, f"Error pushing: {str(e)}"
+    def pull(self) -> Tuple[bool, str]:
+        try:
+            result = subprocess.run(["git", "pull"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=120)
+            return (True, result.stdout.strip()) if result.returncode == 0 else (False, result.stderr.strip())
+        except Exception as e: return False, f"Error pulling: {str(e)}"
+    def create_branch(self, name: str) -> Tuple[bool, str]:
+        try: subprocess.run(["git", "checkout", "-b", name], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10, check=True); return True, f"Created and switched to branch '{name}'"
+        except Exception as e: return False, f"Error creating branch: {str(e)}"
+    def switch_branch(self, name: str) -> Tuple[bool, str]:
+        try: subprocess.run(["git", "checkout", name], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10, check=True); return True, f"Switched to branch '{name}'"
+        except Exception as e: return False, f"Error switching branch: {str(e)}"
+    def stash(self) -> Tuple[bool, str]:
+        try:
+            result = subprocess.run(["git", "stash"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            return (True, result.stdout.strip()) if result.returncode == 0 else (False, result.stderr.strip() or "Nothing to stash")
+        except Exception as e: return False, f"Error stashing: {str(e)}"
+    def stash_pop(self) -> Tuple[bool, str]:
+        try:
+            result = subprocess.run(["git", "stash", "pop"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+            return (True, result.stdout.strip()) if result.returncode == 0 else (False, result.stderr.strip())
+        except Exception as e: return False, f"Error popping stash: {str(e)}"
+
+class AIModelClient:
+    def __init__(self, provider: str, api_key: str, base_url: str, model: str):
+        self.provider = provider; self.api_key = api_key; self.base_url = base_url; self.model = model; self.session = requests.Session()
+    def _request(self, method: str, url: str, **kwargs) -> requests.Response:
+        max_retries = 3
+        for attempt in range(max_retries):
+            resp = self.session.get(url, **kwargs) if method.upper() == 'GET' else self.session.post(url, **kwargs)
+            if resp.status_code == 429:
+                retry_delay = 60
+                try:
+                    data = resp.json()
+                    if "error" in data and "details" in data["error"]:
+                        for detail in data["error"]["details"]:
+                            if "retryDelay" in detail: retry_delay = int(''.join(filter(str.isdigit, detail["retryDelay"]))); break
+                    elif "Retry-After" in resp.headers: retry_delay = int(resp.headers["Retry-After"])
+                except Exception: pass
+                console.print(f"\n[yellow]⚠️ Rate limit (429). Waiting {retry_delay}s before retry ({attempt + 1}/{max_retries})...[/yellow]")
+                time.sleep(retry_delay + 1); continue
+            return resp
+        return resp
+    def list_models(self) -> List[ModelInfo]:
+        models = []
+        try:
+            if self.provider in ["openai", "openrouter", "deepseek", "mistral", "groq", "qwen"]:
+                headers = {"Authorization": f"Bearer {self.api_key}"}
+                resp = self._request('GET', f"{self.base_url.rstrip('/')}/models", headers=headers, timeout=15)
+                if resp.ok:
+                    for m in resp.json().get("data", []): models.append(ModelInfo(id=m.get("id", ""), name=m.get("id", ""), provider=self.provider))
+            elif self.provider == "anthropic":
+                resp = self._request('GET', "https://api.anthropic.com/v1/models", headers={"x-api-key": self.api_key, "anthropic-version": "2023-06-01"}, timeout=15)
+                if resp.ok:
+                    for m in resp.json().get("data", []): models.append(ModelInfo(id=m.get("id", ""), name=m.get("display_name", m.get("id", "")), provider=self.provider))
+            elif self.provider == "google":
+                resp = self._request('GET', f"https://generativelanguage.googleapis.com/v1beta/models?key={self.api_key}", timeout=15)
+                if resp.ok:
+                    for m in resp.json().get("models", []):
+                        if "generateContent" in m.get("supportedGenerationMethods", []): models.append(ModelInfo(id=m.get("name", "").replace("models/", ""), name=m.get("displayName", ""), provider=self.provider))
+            elif self.provider == "ollama":
+                base = self.base_url.replace("/v1", "").rstrip('/')
+                resp = self._request('GET', f"{base}/api/tags", timeout=15)
+                if resp.ok:
+                    for m in resp.json().get("models", []): models.append(ModelInfo(id=m.get("name", ""), name=m.get("name", ""), provider=self.provider))
+        except Exception: pass
+        if not models:
+            provider_config = ProviderRegistry().get_provider(self.provider)
+            models.append(ModelInfo(provider_config.default_model if provider_config else self.model, self.model, self.provider))
+        return models
+    def chat(self, messages: List[Dict], stream: bool = True) -> str:
+        if self.provider == "anthropic": return self._anthropic_chat(messages, stream)
+        elif self.provider == "google": return self._google_chat(messages, stream)
+        elif self.provider == "ollama": return self._ollama_chat(messages, stream)
+        return self._openai_style_chat(messages, stream)
+    def _openai_style_chat(self, messages: List[Dict], stream: bool) -> str:
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+        payload = {"model": self.model, "messages": messages, "stream": stream}
+        try:
+            resp = self._request('POST', f"{self.base_url.rstrip('/')}/chat/completions", headers=headers, json=payload, stream=stream, timeout=180)
+            if not resp.ok: return f"Error: {resp.status_code} - {resp.text}"
+            return self._handle_stream(resp) if stream else resp.json().get("choices", [{}])[0].get("message", {}).get("content", "")
+        except Exception as e: return f"Error: {str(e)}"
+    def _anthropic_chat(self, messages: List[Dict], stream: bool) -> str:
+        system_msg = next((m["content"] for m in messages if m["role"] == "system"), "")
+        anthropic_messages = [{"role": m["role"], "content": m["content"]} for m in messages if m["role"] != "system"]
+        headers = {"x-api-key": self.api_key, "anthropic-version": "2023-06-01", "Content-Type": "application/json"}
+        payload = {"model": self.model, "messages": anthropic_messages, "max_tokens": 4096, "system": system_msg, "stream": stream}
+        try:
+            resp = self._request('POST', f"{self.base_url.rstrip('/')}/messages", headers=headers, json=payload, stream=stream, timeout=180)
+            if not resp.ok: return f"Error: {resp.status_code} - {resp.text}"
+            return self._handle_stream(resp) if stream else resp.json().get("content", [{}])[0].get("text", "")
+        except Exception as e: return f"Error: {str(e)}"
+    def _google_chat(self, messages: List[Dict], stream: bool) -> str:
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model}:streamGenerateContent?alt=sse&key={self.api_key}" if stream else f"https://generativelanguage.googleapis.com/v1beta/models/{self.model}:generateContent?key={self.api_key}"
+        contents = [{"role": "user" if m["role"] == "user" else "model", "parts": [{"text": m["content"]}]} for m in messages if m["role"] != "system"]
+        sys_msg = next((m["content"] for m in messages if m["role"] == "system"), "")
+        payload = {"contents": contents}
+        if sys_msg: payload["system_instruction"] = {"parts": [{"text": sys_msg}]}
+        try:
+            resp = self._request('POST', url, json=payload, timeout=180, stream=stream)
+            if not resp.ok: return f"Error: {resp.status_code} - {resp.text}"
+            return self._handle_stream(resp) if stream else resp.json().get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+        except Exception as e: return f"Error: {str(e)}"
+    def _ollama_chat(self, messages: List[Dict], stream: bool) -> str:
+        base = self.base_url.replace("/v1", "").rstrip('/')
+        try:
+            resp = self._request('POST', f"{base}/api/chat", json={"model": self.model, "messages": messages, "stream": stream}, stream=stream, timeout=180)
+            if not resp.ok: return f"Error: {resp.status_code} - {resp.text}"
+            return self._handle_stream(resp) if stream else resp.json().get("message", {}).get("content", "")
+        except Exception as e: return f"Error: {str(e)}"
+    def _handle_stream(self, resp) -> str:
+        full_response = ""
+        try:
+            for line in resp.iter_lines():
+                if not line: continue
+                line_str = line.decode('utf-8').strip()
+                if not line_str: continue
+                if line_str.startswith('data: '):
+                    json_str = line_str[6:]
+                    if json_str.strip() == '[DONE]': break
+                    try: data = json.loads(json_str)
+                    except: continue
+                else:
+                    try: data = json.loads(line_str)
+                    except: continue
+                content = None
+                if "choices" in data and data["choices"]: content = data["choices"][0].get("delta", {}).get("content")
+                elif data.get("type") == "content_block_delta": content = data.get("delta", {}).get("text")
+                elif "candidates" in data and data["candidates"]:
+                    parts = data["candidates"][0].get("content", {}).get("parts", [])
+                    if parts and "text" in parts[0]: content = parts[0]["text"]
+                elif "message" in data: content = data["message"].get("content")
+                if content is None:
+                    for key in ["content", "text", "response"]:
+                        if key in data and isinstance(data[key], str): content = data[key]; break
+                if content:
+                    console.print(content, end="", markup=False, highlight=False)
+                    full_response += content
+        except Exception as e: console.print(f"\n[red]Stream error: {str(e)}[/red]")
+        console.print()
+        return full_response
+
+class SamCodeCLI:
+    def __init__(self):
+        self.workspace_dir = os.getcwd()
+        self.config_dir = os.path.join(self.workspace_dir, ".samcode")
+        self.config_path = os.path.join(self.config_dir, "config.json")
+        os.makedirs(self.config_dir, exist_ok=True)
+        self.provider_registry = ProviderRegistry()
+        self.active_provider = "openai"
+        self.active_model = "gpt-4o"
+        self.api_key = ""
+        self.custom_base_url = ""
+        self.caveman_mode = CavemanMode.OFF
+        self.session_context = [] 
+        self.file_manager = FileSystemManager(self.workspace_dir)
+        self.command_runner = CommandRunner(self.workspace_dir)
+        self.git_manager = GitManager(self.workspace_dir, console)
+        self.command_completer = WordCompleter(['/connect', '/models', '/upload', '/clear-uploads', '/caveman', '/clear', '/exit', '/help', '/aboutme', '/searchweb', '/git'], sentence=True)
+        self.prompt_text = FormattedText([('ansicyan bold', '❯ ')])
+        self.load_configuration()
+
+    def load_configuration(self):
+        if os.path.exists(self.config_path):
+            try:
+                with open(self.config_path, "r") as f:
+                    data = json.load(f)
+                    self.active_provider = data.get("provider", self.active_provider)
+                    self.active_model = data.get("model", self.active_model)
+                    self.api_key = data.get("api_key", "")
+                    self.custom_base_url = data.get("custom_base_url", "")
+                    caveman_val = data.get("caveman_mode", 0)
+                    self.caveman_mode = CavemanMode(caveman_val) if caveman_val in [0, 1, 2] else CavemanMode.OFF
+            except: pass
+    
+    def save_configuration(self):
+        with open(self.config_path, "w") as f:
+            json.dump({"provider": self.active_provider, "model": self.active_model, "api_key": self.api_key, "custom_base_url": self.custom_base_url, "caveman_mode": self.caveman_mode.value}, f, indent=2)
+    
+    def get_client(self) -> Optional[AIModelClient]:
+        provider_config = self.provider_registry.get_provider(self.active_provider)
+        if not provider_config: return None
+        base_url = self.custom_base_url if self.custom_base_url else provider_config.base_url
+        return AIModelClient(self.active_provider, self.api_key, base_url, self.active_model)
+
+    def show_main_header(self):
+        print("\033[2J\033[H", end="")
+        header_table = Table(show_header=False, box=None, padding=(0, 1))
+        header_table.add_column(style="bold cyan", justify="left")
+        header_table.add_column(style="dim", justify="center")
+        header_table.add_column(style="bold green", justify="right")
+        caveman_indicator = f" | [red]🦴 {self.caveman_mode.name}[/red]" if self.caveman_mode != CavemanMode.OFF else ""
+        upload_indicator = f" | [magenta]📎 {len(self.session_context)} Docs[/magenta]" if self.session_context else ""
+        git_indicator = ""
+        if self.git_manager.is_repo():
+            branch = self.git_manager.get_current_branch()
+            git_indicator = f" | [yellow]🌿 {branch}[/yellow]"
+        header_table.add_row("⚡ SamCode CLI", "Autonomous Coding Agent", f"{self.active_provider} | {self.active_model[:20]}{caveman_indicator}{upload_indicator}{git_indicator}")
+        console.print(Panel(header_table, border_style="bright_black", padding=(0, 1)))
+        console.print("[dim]Type your request naturally, or use /help for commands.[/dim]\n")
+
+    def cmd_connect(self):
+        console.print("\n[bold cyan]🔗 Provider Configuration[/bold cyan]\n")
+        providers = self.provider_registry.list_providers()
+        selected = questionary.select("Select AI Provider:", choices=[Choice(f"{config.name} ({name})", name) for name, config in providers]).ask()
+        if not selected: return
+        self.active_provider = selected
+        provider_config = self.provider_registry.get_provider(selected)
+        if provider_config.auth_type != "none":
+            self.api_key = Prompt.ask(f"[cyan]Enter API Key for {provider_config.name}[/cyan]", password=True)
+        if selected == "custom":
+            self.custom_base_url = Prompt.ask("[cyan]Enter Custom Base URL[/cyan]")
+        self.save_configuration()
+        console.print(f"\n[green]✓ Connected to {provider_config.name}[/green]\n")
+        if Confirm.ask("Select a model?", default=True): self.cmd_models()
+
+    def cmd_models(self):
+        console.print("\n[bold cyan]📋 Model Selector[/bold cyan]\n")
+        client = self.get_client()
+        if not client or not self.api_key: console.print("[red]Configure provider first with /connect[/red]"); return
+        console.print("[cyan]Fetching models from API...[/cyan]")
+        models = client.list_models()
+        if not models: console.print("[red]Could not fetch models[/red]"); return
+        console.print(f"\n[green]✓ Found {len(models)} model(s)[/green]\n")
+        models_per_page = 30; total_pages = (len(models) + models_per_page - 1) // models_per_page; current_page = 0
+        while True:
+            start_idx = current_page * models_per_page; end_idx = min(start_idx + models_per_page, len(models))
+            console.print(f"[bold cyan]📋 Model Selector[/bold cyan] | [dim]Page {current_page + 1}/{total_pages} | Showing {start_idx + 1}-{end_idx} of {len(models)}[/dim]")
+            page_models = models[start_idx:end_idx]; items = []
+            for i, m in enumerate(page_models):
+                actual_idx = start_idx + i + 1; name = m.id if len(m.id) <= 35 else m.id[:32] + "..."
+                items.append(f"[cyan]{actual_idx:<4}[/cyan] {name}")
+            num_cols = max(1, console.width // 40)
+            if num_cols > 4: num_cols = 4 
+            table = Table(show_header=False, box=None, padding=(0, 2), expand=True)
+            for _ in range(num_cols): table.add_column(ratio=1, overflow="fold")
+            for i in range(0, len(items), num_cols):
+                row = items[i:i+num_cols]
+                while len(row) < num_cols: row.append("")
+                table.add_row(*row)
+            console.print(table)
+            console.print("[dim]Type a number to select, 'more' for next, 'less' for previous.[/dim]")
+            while True:
+                user_input = Prompt.ask("[bold cyan]❯[/bold cyan]").strip().lower()
+                if user_input == "more":
+                    if current_page < total_pages - 1: current_page += 1; print("\033[2J\033[H", end=""); break
+                    else: console.print("[yellow]⚠️ Already on the last page.[/yellow]")
+                elif user_input in ["less", "prev", "back"]:
+                    if current_page > 0: current_page -= 1; print("\033[2J\033[H", end=""); break
+                    else: console.print("[yellow]️ Already on the first page.[/yellow]")
+                else:
+                    try:
+                        idx = int(user_input) - 1
+                        if 0 <= idx < len(models):
+                            self.active_model = models[idx].id; self.save_configuration(); print("\033[2J\033[H", end=""); console.print(f"[green]✓ Model set to: {self.active_model}[/green]\n"); return
+                        else: console.print("[red]⚠️ Number out of range. Please try again.[/red]")
+                    except ValueError: console.print("[yellow]⚠️ Please choose a model by number, or type 'more'/'less'.[/yellow]")
+
+    def cmd_caveman(self):
+        current_val = self.caveman_mode.value; next_val = (current_val + 1) % 3; self.caveman_mode = CavemanMode(next_val); self.save_configuration()
+        if self.caveman_mode == CavemanMode.OFF: console.print("[green]🔊 Caveman Mode OFF. Normal verbosity.[/green]")
+        elif self.caveman_mode == CavemanMode.BASIC: console.print("[yellow]🔉 Caveman Mode BASIC. Concise, no fluff.[/yellow]")
+        elif self.caveman_mode == CavemanMode.ULTRA: console.print("[red]🔇 Caveman Mode ULTRA. Maximum token saving. Grunt-like brevity.[/red]")
+        self.show_main_header()
+
+    def cmd_upload(self, filepath: str = ""):
+        if not filepath: filepath = Prompt.ask("[cyan]Enter file path to upload[/cyan]").strip()
+        if not filepath: return
+        filepath = filepath.strip('\'"')
+        if not os.path.exists(filepath): console.print(f"[red]✗ File not found: {filepath}[/red]"); return
+        filename = Path(filepath).name; console.print(f"[cyan]📄 Processing {filename}...[/cyan]")
+        extracted_text = DocumentReader.extract_text(filepath)
+        if extracted_text.startswith("[Error"): console.print(f"[red]{extracted_text}[/red]"); return
+        if len(extracted_text) > 20000: extracted_text = extracted_text[:20000] + "\n\n... [CONTENT TRUNCATED DUE TO LENGTH] ..."
+        self.session_context.append({"filename": filename, "content": extracted_text})
+        preview = extracted_text[:200].replace('\n', ' ') + "..." if len(extracted_text) > 200 else extracted_text.replace('\n', ' ')
+        panel = Panel(f"[dim]{preview}[/dim]", title=f"[bold green]✓ Uploaded: {filename}[/bold green]", border_style="green", padding=(1, 2))
+        console.print(panel); console.print(f"[dim]Added to session context. The agent can now see this document.[/dim]\n"); self.show_main_header()
+
+    def cmd_clear_uploads(self):
+        self.session_context = []; console.print("[yellow]🗑️ All uploaded documents cleared from session context.[/yellow]\n"); self.show_main_header()
+
+    def cmd_aboutme(self):
+        console.print()
+        about_text = Text()
+        about_text.append("SamCode CLI", style="bold cyan"); about_text.append(" is an advanced autonomous coding agent.\n\n")
+        about_text.append("👨‍💻 Developed by: ", style="bold"); about_text.append("Magra Houssem Eddine\n", style="bold green")
+        about_text.append("\n🚀 Other Projects:\n", style="bold"); about_text.append("  • ", style="dim"); about_text.append("Sam Code IDE", style="bold yellow"); about_text.append(" - A powerful integrated development environment.\n", style="dim")
+        about_text.append("  • ", style="dim"); about_text.append("Sam Agent", style="bold yellow"); about_text.append(" - My twin brother! Another autonomous agent.\n", style="dim")
+        about_text.append("\n🌐 Official Website: ", style="bold"); about_text.append("https://samcode-26.web.app\n", style="bold blue underline")
+        panel = Panel(about_text, title="[bold magenta]✨ About SamCode ✨[/bold magenta]", border_style="bright_magenta", padding=(1, 2), expand=False)
+        console.print(panel, justify="center"); console.print()
+
+    def cmd_search_web(self, query: str = ""):
+        if not query: query = Prompt.ask("[cyan]Enter search query[/cyan]").strip()
+        if not query: return
+        search_url = f"https://duckduckgo.com/?q={urllib.parse.quote(query)}"
+        console.print(f"\n[cyan]🌐 Opening default browser to: {search_url}[/cyan]")
+        try: webbrowser.open(search_url)
+        except Exception: console.print("[yellow]Could not open browser automatically.[/yellow]")
+        console.print(f"[cyan]📡 Fetching text snippets for AI synthesis...[/cyan]")
+        search_results = search_web(query)
+        client = self.get_client()
+        if not client or not self.api_key: console.print("[red]Configure AI first with /connect[/red]"); return
+        if search_results.startswith("[SCRAPE_FAILED"):
+            console.print("[yellow]⚠️ Couldn't automatically scrape text (DuckDuckGo blocked the bot).[/yellow]")
+            console.print("[dim]Please look at your browser for the results. I will answer based on my general knowledge.[/dim]\n")
+            ai_prompt = f"""The user wants to know about: "{query}"
+            I tried to search the web, but the search engine blocked my automated request. 
+            Please answer the user's query to the best of your ability using your existing knowledge. 
+            If you don't know, tell the user to check the browser tab that just opened."""
+        else:
+            console.print(f"[green]✓ Found search results. Asking AI to synthesize...[/green]\n")
+            ai_prompt = f"""The user wants to know about: "{query}"
+            I have searched the web and found the following top results:
+            {search_results}
+            Based ONLY on the search results above, provide a comprehensive, accurate, and well-structured answer. Do not make up information."""
+
+        messages = [
+            {"role": "system", "content": "You are an expert research assistant. Provide a clear, accurate, and helpful answer. Use markdown formatting."},
+            {"role": "user", "content": ai_prompt}
+        ]
+        
+        console.print(f"\n[bold cyan]🤖 AI Synthesizing Results...[/bold cyan]\n")
+        client.chat(messages, stream=True)
+        console.print()
+
+    def cmd_git(self):
+        console.print("\n[bold cyan]🌿 Git Operations[/bold cyan]\n")
+        if not self.git_manager.is_git_installed(): console.print("[red]✗ Git is not installed on your system.[/red]"); console.print("[dim]Please install Git from https://git-scm.com/[/dim]\n"); return
+        auth_status = self.git_manager.check_github_auth()
+        if auth_status["logged_in"]: console.print(f"[green]✓ GitHub Auth:[/green] {auth_status['method']} - {auth_status['user']}\n")
+        else: console.print("[yellow]⚠️ GitHub Auth:[/yellow] Not logged in\n"); console.print("[dim]To log in, run: gh auth login[/dim]\n")
+        if not self.git_manager.is_repo():
+            console.print("[yellow]⚠️ No Git repository found in this workspace.[/yellow]\n")
+            if Confirm.ask("Would you like to initialize a new Git repository?", default=True): self._initialize_git_repo()
+            return
+        status = self.git_manager.get_status()
+        if "error" in status: console.print(f"[red]{status['error']}[/red]\n"); return
+        branch = status.get("branch", "unknown"); remote = status.get("remote", "none")
+        total_changes = len(status.get("staged", [])) + len(status.get("unstaged", [])) + len(status.get("untracked", []))
+        console.print(f"[dim]Branch: [bold]{branch}[/bold] | Remote: [bold]{remote or 'none'}[/bold] | Changes: [bold]{total_changes}[/bold][/dim]\n")
+        actions = [Choice("📊 View Status (see all changes)", "status"), Choice("📝 Commit Changes", "commit"), Choice("⬆️  Push to Remote", "push"), Choice("⬇️  Pull from Remote", "pull"), Choice("🌿 Branches (list/create/switch)", "branch"), Choice("📜 Recent Commits (log)", "log"), Choice("🔍 View Diff (detailed changes)", "diff"), Choice("📦 Stash Changes (save temporarily)", "stash"), Choice("🔗 Change Remote URL", "remote"), Choice("🔑 Check GitHub Login", "auth")]
+        action = questionary.select("Select Git Operation:", choices=actions).ask()
+        if not action: return
+        if action == "status": self._git_show_status(status)
+        elif action == "commit": self._git_commit()
+        elif action == "push": self._git_push()
+        elif action == "pull": self._git_pull()
+        elif action == "branch": self._git_branch_menu()
+        elif action == "log": self._git_log()
+        elif action == "diff": self._git_diff()
+        elif action == "stash": self._git_stash_menu()
+        elif action == "remote": self._git_change_remote()
+        elif action == "auth": self._git_check_auth()
+        self.show_main_header()
+
+    def _initialize_git_repo(self):
+        console.print("\n[bold cyan] Initialize Git Repository[/bold cyan]\n")
+        success, msg = self.git_manager.init_repo()
+        if not success: console.print(f"[red]✗ {msg}[/red]\n"); return
+        console.print(f"[green]✓ {msg}[/green]\n")
+        
+        # --- AUTOMATIC GITIGNORE PROTECTION ---
+        gitignore_path = os.path.join(self.workspace_dir, ".gitignore")
+        ignore_entry = "\n.samcode/\n"
+        
+        if os.path.exists(gitignore_path):
+            with open(gitignore_path, "r") as f:
+                content = f.read()
+            if ".samcode/" not in content:
+                with open(gitignore_path, "a") as f:
+                    f.write(ignore_entry)
+                console.print("[green]✓ Automatically added .samcode/ to existing .gitignore[/green]\n")
+        else:
+            with open(gitignore_path, "w") as f:
+                f.write("# Automatically generated by SamCode CLI to protect API keys\n")
+                f.write(ignore_entry)
+            console.print("[green]✓ Automatically created .gitignore to protect .samcode/ folder[/green]\n")
+        # ----------------------------------------
+
+        try:
+            user_check = subprocess.run(["git", "config", "user.name"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=5)
+            if not user_check.stdout.strip():
+                console.print("[yellow]Git user not configured. Let's set it up:[/yellow]\n")
+                user_name = Prompt.ask("[cyan]Your name[/cyan]"); user_email = Prompt.ask("[cyan]Your email[/cyan]")
+                subprocess.run(["git", "config", "user.name", user_name], cwd=self.workspace_dir, timeout=5)
+                subprocess.run(["git", "config", "user.email", user_email], cwd=self.workspace_dir, timeout=5)
+                console.print(f"[green]✓ Git user set to: {user_name} <{user_email}>[/green]\n")
+        except Exception: pass
+        console.print("[dim]You'll need a GitHub repository URL. Format: https://github.com/username/repo.git[/dim]\n")
+        repo_url = Prompt.ask("[cyan]Enter GitHub repository URL[/cyan]").strip()
+        if not repo_url: console.print("[yellow]Repository URL is required. Aborting.[/yellow]\n"); return
+        success, msg = self.git_manager.add_remote(repo_url)
+        if not success: console.print(f"[red]✗ {msg}[/red]\n"); return
+        console.print(f"[green]✓ {msg}[/green]\n")
+        console.print("[cyan]📦 Staging all files...[/cyan]")
+        success, msg = self.git_manager.add_all()
+        if not success: console.print(f"[red]✗ {msg}[/red]\n"); return
+        console.print(f"[green]✓ {msg}[/green]\n")
+        commit_msg = Prompt.ask("[cyan]Initial commit message[/cyan]", default="Initial commit")
+        success, msg = self.git_manager.commit(commit_msg)
+        if not success: console.print(f"[red]✗ {msg}[/red]\n"); return
+        console.print(f"[green]✓ Committed: {msg}[/green]\n")
+        console.print("[cyan]⬆️  Pushing to GitHub...[/cyan]")
+        if Confirm.ask("Push to remote now?", default=True):
+            success, msg = self.git_manager.push(force=True)
+            if success: console.print(f"[green]✓ Successfully pushed to GitHub![/green]\n"); console.print(f"[dim]Repository: {repo_url}[/dim]\n")
+            else: console.print(f"[red]✗ Push failed: {msg}[/red]"); console.print("[dim]This might be due to authentication. Try running: gh auth login[/dim]\n")
+        else: console.print("[yellow]Skipped push. Run /git → Push when ready.[/yellow]\n")
+
+    def _git_show_status(self, status: Dict):
+        console.print(f"\n[bold cyan]📊 Git Status - Branch: {status.get('branch', 'unknown')}[/bold cyan]\n")
+        if not status.get("has_changes"): console.print("[green]✓ Working tree clean. No changes to commit.[/green]\n"); return
+        if status.get("staged"):
+            console.print("[bold green]Staged (ready to commit):[/bold green]")
+            for item in status["staged"]: console.print(f"  {item['file']} ({item['status']})")
+            console.print()
+        if status.get("unstaged"):
+            console.print("[bold yellow]Modified (not staged):[/bold yellow]")
+            for item in status["unstaged"]: console.print(f"  {item['file']} ({item['status']})")
+            console.print()
+        if status.get("untracked"):
+            console.print("[bold magenta]Untracked (new files):[/bold magenta]")
+            for f in status["untracked"]: console.print(f"  {f}")
+            console.print()
+
+    def _git_commit(self):
+        console.print("\n[bold cyan]📝 Commit Changes[/bold cyan]\n")
+        status = self.git_manager.get_status()
+        if "error" in status: console.print(f"[red]{status['error']}[/red]\n"); return
+        total_changes = len(status.get("staged", [])) + len(status.get("unstaged", [])) + len(status.get("untracked", []))
+        if total_changes == 0: console.print("[yellow]No changes to commit.[/yellow]\n"); return
+        console.print(f"Found {total_changes} change(s).")
+        if Confirm.ask("Stage all changes (git add -A)?", default=True):
+            success, msg = self.git_manager.add_all()
+            if not success: console.print(f"[red]✗ {msg}[/red]\n"); return
+        commit_msg = Prompt.ask("[cyan]Commit message[/cyan]")
+        if not commit_msg: console.print("[yellow]Commit message is required.[/yellow]\n"); return
+        success, msg = self.git_manager.commit(commit_msg)
+        if success: console.print(f"\n[green]✓ Committed successfully[/green]\n"); console.print(f"[dim]{msg}[/dim]\n")
+        else: console.print(f"\n[red]✗ {msg}[/red]\n")
+
+    def _git_push(self):
+        console.print("\n[bold cyan]⬆️  Push to Remote[/bold cyan]\n")
+        remote = self.git_manager.get_remote_url()
+        if not remote: console.print("[yellow]No remote configured. Use 'Change Remote URL' first.[/yellow]\n"); return
+        branch = self.git_manager.get_current_branch()
+        console.print(f"[dim]Branch: {branch} | Remote: {remote}[/dim]\n")
+        force = Confirm.ask("Force push? (⚠️ Overwrites remote history)", default=False)
+        console.print("[cyan]Pushing...[/cyan]")
+        success, msg = self.git_manager.push(branch, force)
+        if success: console.print(f"\n[green]✓ Successfully pushed to {remote}[/green]\n")
+        else: console.print(f"\n[red]✗ Push failed[/red]\n[dim]{msg}[/dim]\n")
+
+    def _git_pull(self):
+        console.print("\n[bold cyan]⬇️  Pull from Remote[/bold cyan]\n")
+        remote = self.git_manager.get_remote_url()
+        if not remote: console.print("[yellow]No remote configured.[/yellow]\n"); return
+        console.print("[cyan]Pulling latest changes...[/cyan]")
+        success, msg = self.git_manager.pull()
+        if success: console.print(f"\n[green]✓ Pull successful[/green]\n[dim]{msg}[/dim]\n")
+        else: console.print(f"\n[red]✗ Pull failed[/red]\n[dim]{msg}[/dim]\n")
+
+    def _git_branch_menu(self):
+        console.print("\n[bold cyan]🌿 Branch Operations[/bold cyan]\n")
+        branches = self.git_manager.get_branches(); current = self.git_manager.get_current_branch()
+        console.print(f"[dim]Current branch: [bold green]{current}[/bold green][/dim]\n")
+        console.print("[bold]Available branches:[/bold]")
+        for b in branches: console.print(f"  {b}{' ← current' if b == current else ''}")
+        console.print()
+        actions = [Choice("Create new branch", "create"), Choice("Switch branch", "switch"), Choice("Delete branch", "delete")]
+        action = questionary.select("Branch action:", choices=actions).ask()
+        if not action: return
+        if action == "create":
+            name = Prompt.ask("[cyan]New branch name[/cyan]").strip()
+            if name:
+                success, msg = self.git_manager.create_branch(name)
+                if success: console.print(f"\n[green]✓ {msg}[/green]\n")
+                else: console.print(f"\n[red]✗ {msg}[/red]\n")
+        elif action == "switch":
+            name = Prompt.ask("[cyan]Branch to switch to[/cyan]", choices=branches if branches else None).strip()
+            if name:
+                success, msg = self.git_manager.switch_branch(name)
+                if success: console.print(f"\n[green]✓ {msg}[/green]\n")
+                else: console.print(f"\n[red]✗ {msg}[/red]\n")
+        elif action == "delete":
+            name = Prompt.ask("[cyan]Branch to delete[/cyan]").strip()
+            if name and name != current:
+                if Confirm.ask(f"Delete branch '{name}'?", default=False):
+                    try:
+                        result = subprocess.run(["git", "branch", "-D", name], cwd=self.workspace_dir, capture_output=True, text=True, timeout=10)
+                        if result.returncode == 0: console.print(f"\n[green]✓ Deleted branch '{name}'[/green]\n")
+                        else: console.print(f"\n[red]✗ {result.stderr.strip()}[/red]\n")
+                    except Exception as e: console.print(f"\n[red]Error: {e}[/red]\n")
+            else: console.print("[yellow]Cannot delete the current branch.[/yellow]\n")
+
+    def _git_log(self):
+        console.print("\n[bold cyan]📜 Recent Commits[/bold cyan]\n")
+        log = self.git_manager.get_log(15)
+        console.print(Panel(f"[dim]{log}[/dim]", title="Git Log", border_style="cyan")); console.print()
+
+    def _git_diff(self):
+        console.print("\n[bold cyan]🔍 View Diff[/bold cyan]\n")
+        diff_type = questionary.select("Show diff for:", choices=[Choice("Unstaged changes", "unstaged"), Choice("Staged changes", "staged")]).ask()
+        if not diff_type: return
+        staged = diff_type == "staged"; diff = self.git_manager.get_diff(staged)
+        if diff and diff != "No changes to show":
+            syntax = Syntax(diff, "diff", theme="monokai", line_numbers=True)
+            title = "Staged Changes" if staged else "Unstaged Changes"
+            console.print(Panel(syntax, title=f"[bold cyan]{title}[/bold cyan]", border_style="cyan"))
+        else: console.print("[yellow]No changes to show.[/yellow]")
+        console.print()
+
+    def _git_stash_menu(self):
+        console.print("\n[bold cyan]📦 Stash Operations[/bold cyan]\n")
+        actions = [Choice("Stash current changes", "stash"), Choice("Pop latest stash", "pop")]
+        action = questionary.select("Stash action:", choices=actions).ask()
+        if not action: return
+        if action == "stash":
+            success, msg = self.git_manager.stash()
+            if success: console.print(f"\n[green]✓ {msg}[/green]\n")
+            else: console.print(f"\n[red]✗ {msg}[/red]\n")
+        elif action == "pop":
+            success, msg = self.git_manager.stash_pop()
+            if success: console.print(f"\n[green]✓ {msg}[/green]\n")
+            else: console.print(f"\n[red]✗ {msg}[/red]\n")
+
+    def _git_change_remote(self):
+        console.print("\n[bold cyan]🔗 Change Remote URL[/bold cyan]\n")
+        current = self.git_manager.get_remote_url()
+        if current: console.print(f"[dim]Current remote: {current}[/dim]\n")
+        new_url = Prompt.ask("[cyan]New remote URL[/cyan]").strip()
+        if new_url:
+            success, msg = self.git_manager.add_remote(new_url)
+            if success: console.print(f"\n[green]✓ {msg}[/green]\n")
+            else: console.print(f"\n[red]✗ {msg}[/red]\n")
+
+    def _git_check_auth(self):
+        console.print("\n[bold cyan]🔑 GitHub Authentication Status[/bold cyan]\n")
+        auth = self.git_manager.check_github_auth()
+        if auth["logged_in"]: console.print(f"[green]✓ Logged in via {auth['method']}[/green]\n[dim]User: {auth['user']}[/dim]\n")
+        else:
+            console.print("[red]✗ Not logged into GitHub[/red]\n")
+            console.print("[bold]To log in:[/bold]\n  1. Install GitHub CLI: https://cli.github.com/\n  2. Run: gh auth login\n  3. Follow the prompts\n")
+
+    def cmd_agent_ask(self, question: str):
+        client = self.get_client()
+        if not client or not self.api_key: console.print("[red]Configure AI first with /connect[/red]"); return
+        files = self.file_manager.scan_workspace()
+        workspace_tree = "\n".join(files) if files else "(Empty workspace)"
+        context_str = ""
+        if self.session_context:
+            context_str = "\n\nUPLOADED DOCUMENTS CONTEXT (The user has uploaded these files, you can reference them directly):\n"
+            for doc in self.session_context: context_str += f"=== {doc['filename']} ===\n{doc['content']}\n\n"
+        caveman_rules = ""
+        if self.caveman_mode == CavemanMode.BASIC: caveman_rules = "\n9. CAVEMAN MODE (BASIC) IS ACTIVE: Be extremely concise. No pleasantries, no fluff. Use short sentences. Get straight to the point."
+        elif self.caveman_mode == CavemanMode.ULTRA: caveman_rules = "\n9. CAVEMAN MODE (ULTRA) IS ACTIVE: MAXIMUM TOKEN SAVING. Output ONLY code or absolute minimum words. No explanations. No greetings. Grunt-like brevity."
+        system_msg = f"""You are SamCode CLI, an expert autonomous AI coding agent.
+You are currently working in the directory: {self.workspace_dir}
+
+Here is the current project structure:
+{workspace_tree}
+{context_str}
+You have access to the following tools to help you complete tasks:
+[READ_FILE: <path>]
+[WRITE_FILE: <path>]
+<full content of the file here>
+[END_WRITE_FILE]
+[RUN_TERMINAL: <command>]
+[SEARCH_CODE: <query>]
+
+CRITICAL RULES:
+1. You have full access to the workspace. NEVER say you cannot access files.
+2. DO NOT use tools unless the user explicitly asks you to modify, create, or analyze specific files/code, or if you absolutely need to read a file to answer a technical question.
+3. If the user greets you, asks a general question, or gives a simple instruction that doesn't require file access, respond directly with text ONLY.
+4. If you MUST use a tool, output the tool call clearly. You may include brief reasoning before the tool call, but ensure the tool syntax is exact.
+5. If you need to see a file's content, use [READ_FILE: <path>].
+6. If you need to create or modify a file, use [WRITE_FILE: <path>] followed by the COMPLETE file content and [END_WRITE_FILE].
+7. If you need to run a terminal command, use [RUN_TERMINAL: <command>].
+8. Once you have completed the task, provide your final answer to the user WITHOUT using any tools.{caveman_rules}"""
+        messages = [{"role": "system", "content": system_msg}, {"role": "user", "content": question}]
+        max_iterations = 20
+        console.print(f"\n[bold cyan]🤖 Agent Activated[/bold cyan]")
+        for i in range(max_iterations):
+            console.print(f"\n[dim]--- Agent Step {i+1} ---[/dim]")
+            console.print("[dim]🤖 Thinking...[/dim]")
+            try:
+                response = client.chat(messages, stream=True)
+                if not response or response.startswith("Error"): console.print(f"\n[red]{response}[/red]"); break
+                write_match = re.search(r'\[WRITE_FILE:\s*(.*?)\](.*?)\[END_WRITE_FILE\]', response, re.DOTALL)
+                single_match = re.search(r'\[(READ_FILE|RUN_TERMINAL|SEARCH_CODE):\s*(.*?)\]', response)
+                tool_executed = False
+                if write_match:
+                    path = write_match.group(1).strip(); content = write_match.group(2).strip()
+                    full_path = os.path.join(self.workspace_dir, path); ext = Path(path).suffix.lstrip('.') or 'text'
+                    if os.path.exists(full_path):
+                        old_content = self.file_manager.read_file(path) or ""
+                        left_panel = Panel(Syntax(old_content, ext, theme="monokai", line_numbers=True), title="[bold red]Original[/bold red]", border_style="red")
+                        right_panel = Panel(Syntax(content, ext, theme="monokai", line_numbers=True), title="[bold green]Proposed[/bold green]", border_style="green")
+                        console.print("\n"); console.print(Columns([left_panel, right_panel], equal=True, expand=True))
+                        if Confirm.ask(f"\n[bold]Apply changes to {path}?[/bold]", default=True):
+                            self.file_manager.write_file(path, content); tool_result = f"Successfully updated {path}."
+                            console.print(f"[green]✓ File updated: {path}[/green]")
+                            tool_result += f"\n\n[SYSTEM INSTRUCTION - SELF REVIEW]: You must now review the file you just modified. Use [READ_FILE: {path}] to check your work. If you find any syntax errors, logical bugs, or missing requirements, fix them immediately using [WRITE_FILE]. Only stop when the code is flawless."
+                        else: tool_result = f"User rejected the changes to {path}."; console.print(f"[yellow]✗ Changes rejected.[/yellow]")
+                    else:
+                        new_file_panel = Panel(Syntax(content, ext, theme="monokai", line_numbers=True), title=f"[bold green]✨ Creating New File: {path}[/bold green]", border_style="green")
+                        console.print("\n"); console.print(new_file_panel)
+                        self.file_manager.write_file(path, content); tool_result = f"Successfully created {path}."
+                        console.print(f"[green]✓ File created: {path}[/green]")
+                        tool_result += f"\n\n[SYSTEM INSTRUCTION - SELF REVIEW]: You must now review the file you just created. Use [READ_FILE: {path}] to check your work. If you find any syntax errors, logical bugs, or missing requirements, fix them immediately using [WRITE_FILE]. Only stop when the code is flawless."
+                    tool_executed = True
+                elif single_match:
+                    tool_name = single_match.group(1); tool_arg = single_match.group(2).strip()
+                    if tool_name == "READ_FILE":
+                        content = self.file_manager.read_file(tool_arg)
+                        tool_result = f"Content of {tool_arg}:\n{content}" if content else f"Error: File '{tool_arg}' not found."
+                        console.print(f"\n[blue]📖 Read file: {tool_arg}[/blue]"); tool_executed = True
+                    elif tool_name == "SEARCH_CODE":
+                        results = self.file_manager.search_in_files(tool_arg)
+                        if not results: tool_result = "No matches found."
+                        else: tool_result = "\n".join([f"{r['file']}: {' | '.join([m[1] for m in r['matches']])}" for r in results])
+                        console.print(f"\n[blue]🔍 Searched code for: {tool_arg}[/blue]"); tool_executed = True
+                    elif tool_name == "RUN_TERMINAL":
+                        console.print(Panel(f"[yellow]{tool_arg}[/yellow]", title="[bold orange3]⚡ Terminal Command Request[/bold orange3]", border_style="orange3"))
+                        if Confirm.ask("Execute this command?", default=True):
+                            success, output = self.command_runner.run(tool_arg)
+                            tool_result = f"Command output:\n{output}"
+                            console.print(Panel(output[:2000], title="Command Output", border_style="green" if success else "red"))
+                            if not success or "[STDERR]" in output: tool_result += "\n\n[SYSTEM INSTRUCTION - AUTO-FIX]: This command FAILED. You MUST analyze the error output above and use [WRITE_FILE] or [RUN_TERMINAL] to fix the issue immediately. Do not ask the user for help, fix it yourself."
+                        else: tool_result = "User rejected the command."; console.print("[yellow]✗ Command rejected.[/yellow]")
+                        tool_executed = True
+                if tool_executed:
+                    messages.append({"role": "assistant", "content": response})
+                    messages.append({"role": "user", "content": f"Tool result:\n{tool_result}\n\nContinue your task."})
+                else: console.print(f"\n[bold green]✓ Task completed.[/bold green]"); break
+            except Exception as e: console.print(f"\n[red]Fatal Error in agent loop: {e}[/red]"); break
+        else: console.print("\n[yellow]⚠️ Agent reached maximum iterations (20).[/yellow]")
+
+    def cmd_help(self):
+        console.print("\n[bold cyan]📚 SamCode CLI Commands[/bold cyan]\n")
+        commands = {"/connect": "Configure AI provider and API key", "/models": "Select AI model dynamically", "/upload <path>": "Upload & extract documents (PDF, DOCX, XLSX, PPTX, Images)", "/clear-uploads": "Clear uploaded documents from session context", "/searchweb <query>": "Search the web (opens browser) & get AI-synthesized answer", "/git": "Native Git operations (commit, push, pull, branch, etc.)", "/caveman": "Cycle token-saving modes (OFF ➔ BASIC ➔ ULTRA)", "/aboutme": "About the developer and SamCode", "/clear": "Clear the screen", "/exit": "Exit SamCode CLI"}
+        for cmd, desc in commands.items(): console.print(f"  [cyan]{cmd:<20}[/cyan] {desc}")
+        console.print("\n[dim]Just type your request naturally to activate the autonomous agent![/dim]\n")
+
+    def run(self):
+        self.show_main_header()
+        if not self.api_key:
+            console.print("[yellow]⚠️ No API key configured. Use /connect to set up.[/yellow]\n")
+            if Confirm.ask("Configure now?", default=True): self.cmd_connect()
+            self.show_main_header()
+        while True:
+            try:
+                # FIXED: Using editing_mode=EditingMode.EMACS for standard shortcuts + custom kb
+                user_input = pt_prompt(
+                    self.prompt_text, 
+                    completer=self.command_completer, 
+                    style=menu_style, 
+                    key_bindings=kb,
+                    editing_mode=EditingMode.EMACS
+                ).strip()
+                if not user_input: continue
+                if user_input.lower() in ["/exit", "/quit", "exit"]: console.print("\n[yellow]Goodbye![/yellow]\n"); break
+                elif user_input.lower() in ["/help", "/h"]: self.cmd_help()
+                elif user_input.lower() in ["/clear", "/cls"]: self.show_main_header()
+                elif user_input.lower() in ["/connect", "/config"]: self.cmd_connect(); self.show_main_header()
+                elif user_input.lower() in ["/models", "/model"]: self.cmd_models()
+                elif user_input.lower() in ["/caveman"]: self.cmd_caveman()
+                elif user_input.lower() in ["/aboutme", "/about"]: self.cmd_aboutme()
+                elif user_input.lower() in ["/git", "/g"]: self.cmd_git()
+                elif user_input.lower().startswith("/searchweb"):
+                    parts = user_input.split(maxsplit=1); query = parts[1] if len(parts) > 1 else ""; self.cmd_search_web(query)
+                elif user_input.lower().startswith("/upload"):
+                    parts = user_input.split(maxsplit=1); path = parts[1] if len(parts) > 1 else ""; self.cmd_upload(path)
+                elif user_input.lower() in ["/clear-uploads", "/clear-up"]: self.cmd_clear_uploads()
+                else: self.cmd_agent_ask(user_input)
+            except KeyboardInterrupt: console.print("\n[dim](Use /exit to quit)[/dim]")
+            except EOFError: break
+
+def main():
+    try:
+        agent = SamCodeCLI()
+        agent.run()
+    except Exception as e:
+        console.print(f"[red]Fatal error: {e}[/red]")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

{samcode_cli-1.0.1 → samcode_cli-1.0.3}/samcode_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: samcode-cli
-Version: 1.0.1
+Version: 1.0.3
 Summary: An autonomous AI coding agent that runs in your terminal.
 Author: Magra Houssem Eddine
 Description-Content-Type: text/markdown

{samcode_cli-1.0.1 → samcode_cli-1.0.3}/samcode_cli.egg-info/SOURCES.txt

@@ -1,4 +1,6 @@
+MANIFEST.in
 README.md
+samcode.py
 setup.py
 samcode_cli.egg-info/PKG-INFO
 samcode_cli.egg-info/SOURCES.txt

{samcode_cli-1.0.1 → samcode_cli-1.0.3}/setup.py

@@ -1,18 +1,17 @@
 from setuptools import setup
 from pathlib import Path
 
-# Automatically read the contents of your README.md
 this_directory = Path(__file__).parent
 long_description = (this_directory / "README.md").read_text(encoding="utf-8")
 
 setup(
     name='samcode-cli',
-    version='1.0.1',  # IMPORTANT: You must bump the version number!
-    description='An autonomous AI coding agent that runs in your terminal.', # Short description for PyPI search
-    long_description=long_description, # The main body of your PyPI page
-    long_description_content_type="text/markdown", # Tells PyPI it's Markdown
+    version='1.0.3',  # IMPORTANT: Bumped version!
+    description='An autonomous AI coding agent that runs in your terminal.',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
     author='Magra Houssem Eddine',
-    py_modules=['samcode'],
+    py_modules=['samcode'],  # This MUST match your filename: samcode.py
     install_requires=[
         'rich', 
         'questionary',