samcode-cli 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

samcode.py

@@ -0,0 +1,1041 @@
+#!/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")
+        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.2.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: samcode-cli
+Version: 1.0.2
+Summary: An autonomous AI coding agent that runs in your terminal.
+Author: Magra Houssem Eddine
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+Requires-Dist: questionary
+Requires-Dist: prompt_toolkit
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: summary
+
+
+# SamCode CLI
+
+[![PyPI version](https://img.shields.io/pypi/v/samcode-cli.svg)](https://pypi.org/project/samcode-cli/)
+[![Python Version](https://img.shields.io/pypi/pyversions/samcode-cli.svg)](https://pypi.org/project/samcode-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**SamCode CLI** is a powerful, autonomous AI coding agent that runs directly in your terminal. Similar to Claude Code and GitHub Copilot Workspace, it reads your project structure, writes and edits code, executes terminal commands, and fixes its own errors—all while keeping your workflow secure and efficient.
+
+## ✨ Key Features
+
+- 🤖 **Autonomous Agentic Loop**: The agent thinks in steps. It reads files, writes code, runs commands, and automatically fixes terminal errors or reviews its own code for bugs.
+- 🌐 **Universal AI Support**: Connect to 15+ providers (OpenAI, Anthropic, Google Gemini, Ollama, Groq, etc.) with dynamic model fetching.
+- 📄 **Universal Document Reader**: Upload and analyze PDFs, Word docs, Excel sheets, PowerPoint presentations, and images directly in the chat.
+- 🔍 **Live Web Search**: Use `/searchweb` to open your browser and let the AI synthesize answers from live search results.
+- **Project Scaffolding**: Use `/init` to instantly scaffold projects for React, Next.js, Django, Spring Boot, Flutter, Rust, and more.
+- 🌿 **Native Git Integration**: A full interactive Git workflow (`/git`) to commit, push, pull, branch, and stash without leaving the agent.
+- 📦 **Auto Dependency Installation**: Automatically detects missing packages and installs them with your approval.
+- 🔒 **Path Sandboxing**: The agent is restricted to your workspace and asks for explicit permission before accessing files outside the current directory.
+- ⌨️ **Advanced Shortcuts**: Emacs-style navigation (Ctrl+A, Ctrl+W, Home/End) in the prompt for fast typing.
+- **Caveman Mode**: Save tokens with ultra-concise, grunt-like AI responses.
+
+## 🚀 Installation
+
+Install SamCode CLI globally from PyPI using pip:
+
+```bash
+pip install samcode-cli
+```
+
+## Commands Reference
+
+### 🤖 Core & AI
+
+| **Command** | **Description**                                               |
+| ----------------- | ------------------------------------------------------------------- |
+| `/connect`      | **Configure AI provider and API key interactively.**          |
+| `/models`       | **Dynamically fetch and select models from your provider.**   |
+| `/caveman`      | **Cycle through token-saving modes (OFF ➔ BASIC ➔ ULTRA).** |
+| `/deps`         | **Toggle auto-approve for dependency installations.**         |
+| `/aboutme`      | **Information about the developer and SamCode.**              |
+
+### 📂 Files & Documents
+
+| **Command**     | **Description**                                                 |
+| --------------------- | --------------------------------------------------------------------- |
+| `/upload <path>`    | **Upload & extract documents (PDF, DOCX, XLSX, PPTX, Images).** |
+| `/clear-uploads`    | **Clear uploaded documents from the session context.**          |
+| `/read-file <path>` | **Read any file using the universal document reader.**          |
+
+### 🌐 Web & Scaffolding
+
+| **Command**      | **Description**                                                    |
+| ---------------------- | ------------------------------------------------------------------------ |
+| `/searchweb <query>` | **Search the web (opens browser) & get an AI-synthesized answer.** |
+| `/init <name>`       | **Scaffold a new project (React, Django, Spring, Flutter, etc.).** |
+
+### 🌿 Git Operations
+
+| **Command** | **Description**                                                                        |
+| ----------------- | -------------------------------------------------------------------------------------------- |
+| `/git`          | **Open the interactive Git menu (Status, Commit, Push, Pull, Branches, Diff, Stash).** |
+
+### ⚙️ System
+
+| **Command** | **Description**                  |
+| ----------------- | -------------------------------------- |
+| `/help`         | **Show all available commands.** |
+| `/clear`        | **Clear the terminal screen.**   |
+| `/exit`         | **Exit SamCode CLI.**            |
+
+## ⌨️ Keyboard Shortcuts
+
+**SamCode CLI uses **`prompt_toolkit` to provide a rich input experience. The following shortcuts work directly in the prompt:
+
+* **Ctrl + A** **: Select all text**
+* **Ctrl + W** **: Delete word backward**
+* **Ctrl + U** **: Clear line backward**
+* **Ctrl + K** **: Delete to end of line**
+* **Home / End** **: Jump to start/end of line**
+* **Shift + Home/End** **: Select to start/end of line**
+* **Ctrl + Left/Right** **: Jump by word**
+
+## 🛡️ Safety & Security
+
+* **Path Sandboxing** **: By default, the agent cannot read, write, or execute commands outside the directory where you launched **`samcode`. If it needs to, it will pause and ask for your explicit permission.
+* **User Approval** **: All file modifications, terminal commands, and dependency installations require your confirmation before execution (unless auto-approve is enabled via **`/deps`).
+* **Self-Review** **: After writing code, the agent automatically reviews its own work to catch syntax errors or logical bugs before moving on.**
+
+## Requirements
+
+* **Python 3.8 or higher**
+* **An API key for your chosen AI provider (OpenAI, Anthropic, Google, etc.)**
+* **Internet connection (except when using local Ollama models)**
+
+## 📝 License
+
+**This project is licensed under the MIT License. See the **[LICENSE]() file for details.
+
+---
+
+*Developed by Magra Houssem Eddine*
+
+```
+
+```

samcode_cli-1.0.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+samcode.py,sha256=gaWxvW_FSYVkB3uOcIRdi09iWYxZnH1cG6N7v5DagQg,69136
+samcode_cli-1.0.2.dist-info/METADATA,sha256=R9B67J-JjuG_LsoqzA8ssWkGzQToyjgPaBEeclQpMhw,6269
+samcode_cli-1.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+samcode_cli-1.0.2.dist-info/entry_points.txt,sha256=pTSNSMG9LYqLdbOR0TZGIQS0I17ZEUdXLEapLCYmyqo,41
+samcode_cli-1.0.2.dist-info/top_level.txt,sha256=ie3RFdU_m6daHft-jFl_UKNkKAA25CItx4-gyRRHbJY,8
+samcode_cli-1.0.2.dist-info/RECORD,,

samcode_cli-1.0.0.dist-info/METADATA

@@ -1,13 +0,0 @@
-Metadata-Version: 2.4
-Name: samcode-cli
-Version: 1.0.0
-Summary: SamCode CLI - Autonomous Coding Agent
-Author: Magra Houssem Eddine
-Requires-Dist: rich
-Requires-Dist: questionary
-Requires-Dist: prompt_toolkit
-Requires-Dist: requests
-Requires-Dist: beautifulsoup4
-Dynamic: author
-Dynamic: requires-dist
-Dynamic: summary

samcode_cli-1.0.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-samcode_cli-1.0.0.dist-info/METADATA,sha256=YNuqqmF_PzG9yb3oe9_zpO2IX3QkiE-NR2OF6kjrfpA,331
-samcode_cli-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-samcode_cli-1.0.0.dist-info/entry_points.txt,sha256=pTSNSMG9LYqLdbOR0TZGIQS0I17ZEUdXLEapLCYmyqo,41
-samcode_cli-1.0.0.dist-info/top_level.txt,sha256=ie3RFdU_m6daHft-jFl_UKNkKAA25CItx4-gyRRHbJY,8
-samcode_cli-1.0.0.dist-info/RECORD,,