samcode-cli 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

samcode.py

@@ -2,9 +2,8 @@
 """
 ╔══════════════════════════════════════════════════════════════════════════════╗
 ║                          S A M C O D E   C L I                              ║
-║                   Autonomous Coding Agent v5.4                              ║
-║              Similar to Claude Code & GitHub Copilot Workspace              ║
-╚══════════════════════════════════════════════════════════════════════════════╝
+║                   Autonomous Coding Agent v6.5 (Full Integration)           ║
+══════════════════════════════════════════════════════════════════════════════╝
 """
 
 import os
@@ -15,13 +14,18 @@ import re
 import time
 import urllib.parse
 import webbrowser
+import warnings
 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
+# Suppress warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", message=".*urllib3.*")
+warnings.filterwarnings("ignore", message=".*NumPy.*")
+
+from rich.console import Console, Group
 from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
@@ -29,7 +33,6 @@ 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
@@ -48,25 +51,31 @@ except ImportError:
     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
+# ✅ FIX: Define console BEFORE the auto-installer loop
+console = Console()
+
 LIBS_TO_INSTALL = {
     'pdfplumber': 'pdfplumber', 'docx': 'python-docx', 'openpyxl': 'openpyxl',
-    'pptx': 'python-pptx', 'PIL': 'Pillow', 'bs4': 'beautifulsoup4'
+    'pptx': 'python-pptx', 'PIL': 'Pillow', 'bs4': 'beautifulsoup4',
+    'chromadb': 'chromadb', 'sentence_transformers': 'sentence-transformers',
+    'ruff': 'ruff', 'pandas': 'pandas',
+    'matplotlib': 'matplotlib', 'seaborn': 'seaborn', 'nbformat': 'nbformat', 'sqlalchemy': 'sqlalchemy',
+    'pyarrow': 'pyarrow', 'psycopg2_binary': 'psycopg2-binary', 'pymysql': 'pymysql',
+    'nbconvert': 'nbconvert'
 }
+
 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()
+        console.print(f"[cyan]Installing {package}...[/cyan]")
+        subprocess.run([sys.executable, "-m", "pip", "install", "--no-cache-dir", package], capture_output=True)
 
 menu_style = Style.from_dict({
     'completion-menu': 'bg:#1e1e1e',
@@ -74,34 +83,134 @@ menu_style = Style.from_dict({
     '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)
+    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 CodebaseMemory:
+    def __init__(self, workspace_dir: str):
+        self.workspace_dir = workspace_dir
+        self.db_path = os.path.join(workspace_dir, ".samcode", "vector_db")
+        os.makedirs(self.db_path, exist_ok=True)
+        self._is_indexed = False
+        self.model = None
+        self.collection = None
+        
+        try:
+            import chromadb
+            from sentence_transformers import SentenceTransformer
+            self.client = chromadb.PersistentClient(path=self.db_path)
+            self.collection = self.client.get_or_create_collection(name="codebase", metadata={"hnsw:space": "cosine"})
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        except Exception as e:
+            console.print(f"[yellow]⚠️ Vector memory unavailable. Run: pip install 'numpy<2' torch transformers sentence-transformers[/yellow]")
+
+    def index_workspace(self, file_manager):
+        if self._is_indexed or not self.model: return
+        console.print("[cyan]🧠 Building vector memory index...[/cyan]")
+        files = file_manager.scan_workspace(max_files=500)
+        docs, ids, metadatas = [], [], []
+        code_extensions = {'.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs', '.html', '.css', '.scss', '.sql', '.sh'}
+        
+        for f in files:
+            if Path(f).suffix.lower() in code_extensions:
+                content = file_manager.read_file(f)
+                if content and len(content) < 10000:
+                    docs.append(f"File: {f}\nContent:\n{content}")
+                    ids.append(f.replace(os.sep, "_"))
+                    metadatas.append({"file": f, "ext": Path(f).suffix.lower()})
+        
+        if docs:
+            embeddings = self.model.encode(docs, show_progress_bar=False).tolist()
+            self.collection.upsert(documents=docs, embeddings=embeddings, ids=ids, metadatas=metadatas)
+            console.print(f"[green]✓ Indexed {len(docs)} files into vector memory.[/green]")
+        self._is_indexed = True
+
+    def search(self, query: str, n_results: int = 3) -> List[Dict]:
+        if not self.model: return []
+        query_embedding = self.model.encode([query]).tolist()
+        results = self.collection.query(query_embeddings=query_embedding, n_results=n_results)
+        return [{"file": m["file"], "snippet": d} for m, d in zip(results["metadatas"][0], results["documents"][0])]
+
+
+class CodeDoctor:
+    INTENT_KEYWORDS = ['fix', 'bug', 'error', 'issue', 'broken', 'not working', 'optimize', 'performance', 'slow', 'refactor', 'clean', 'unused', 'dead code', 'analyze', 'malfunction', 'improve', 'lint', 'format', 'style', 'best practice', 'debug']
+    
+    def __init__(self, workspace_dir: str): self.workspace_dir = workspace_dir
+    def should_analyze(self, user_prompt: str) -> bool:
+        return any(kw in user_prompt.lower() for kw in self.INTENT_KEYWORDS)
+    
+    def get_relevant_files(self, user_prompt: str, file_manager, memory=None) -> List[str]:
+        if memory and memory.model:
+            results = memory.search(user_prompt, n_results=5)
+            if results: return [r['file'] for r in results]
+        files = file_manager.scan_workspace(max_files=100)
+        mentioned = [f for f in files if Path(f).stem.lower() in user_prompt.lower() or f.lower() in user_prompt.lower()]
+        if not mentioned: return [f for f in files if any(ext in f for ext in ['.py', '.js', '.ts', '.jsx', '.tsx'])][:10]
+        return mentioned[:10]
+    
+    def run_analysis(self, files: List[str]) -> Dict[str, str]:
+        findings = {}
+        for filepath in files:
+            ext = Path(filepath).suffix.lower()
+            full_path = os.path.join(self.workspace_dir, filepath)
+            if not os.path.exists(full_path): continue
+            try:
+                if ext == '.py':
+                    result = subprocess.run(['ruff', 'check', '--output-format=json', full_path], cwd=self.workspace_dir, capture_output=True, text=True, timeout=30)
+                    if result.stdout.strip():
+                        issues = json.loads(result.stdout)
+                        if issues:
+                            summary = f"\n🐍 Python Issues in {filepath}:\n"
+                            for issue in issues[:5]:
+                                summary += f"  • Line {issue.get('location', {}).get('row', '?')}: [{issue.get('code', '')}] {issue.get('message', '')}\n"
+                            findings[filepath] = summary
+            except: pass
+        return findings
+
+
+class UniversalDataReader:
+    @staticmethod
+    def read(source: str, **kwargs) -> Tuple[Any, str]:
+        import pandas as pd
+        if source.startswith(('postgresql://', 'mysql://', 'sqlite:///', 'mssql+pyodbc://')):
+            try:
+                from sqlalchemy import create_engine
+                engine = create_engine(source)
+                query = kwargs.get('query', 'SELECT * FROM information_schema.tables LIMIT 10')
+                df = pd.read_sql(query, engine)
+                return df, f"🗄️ Database Source: {source.split('@')[-1]}\nQuery executed successfully."
+            except Exception as e: return None, f"[DB_ERROR] {str(e)}"
+
+        ext = Path(source).suffix.lower()
+        try:
+            if ext == '.csv': df = pd.read_csv(source, **kwargs)
+            elif ext in ['.xlsx', '.xls']: df = pd.read_excel(source, sheet_name=kwargs.get('sheet_name', 0), **kwargs)
+            elif ext == '.parquet': df = pd.read_parquet(source, **kwargs)
+            elif ext == '.feather': df = pd.read_feather(source, **kwargs)
+            elif ext == '.json': df = pd.read_json(source, orient=kwargs.get('orient', 'columns'), **kwargs)
+            elif ext == '.hdf5': df = pd.read_hdf(source, key=kwargs.get('key'), **kwargs)
+            else: return None, f"[UNSUPPORTED] Extension '{ext}' is not supported."
+            meta = f"📊 Dataset: {Path(source).name}\nRows: {len(df):,} | Columns: {len(df.columns)}\nDtypes:\n{df.dtypes.to_dict()}\nMissing Values:\n{df.isnull().sum().to_dict()}\nFirst 3 Rows Preview:\n{df.head(3).to_markdown()}"
+            return df, meta
+        except Exception as e: return None, f"[READ_ERROR] {str(e)}"
+
+
 class DocumentReader:
     @staticmethod
     def extract_text(filepath: str) -> str:
@@ -109,88 +218,40 @@ class DocumentReader:
         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]"
+                return "\n".join([p.extract_text() or "" for p in pdfplumber.open(filepath).pages])
             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)
+                return "\n".join([p.text for p in docx.Document(filepath).paragraphs if p.text.strip()])
             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)
+                return "\n".join([f"\n--- Sheet: {s} ---\n" + "\n".join([" | ".join([str(c) if c else "" for c in r]) for r in wb[s].iter_rows(values_only=True)]) for s in wb.sheetnames])
             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)
+                return "\n".join([f"\n--- Slide {i+1} ---\n" + "\n".join([sh.text for sh in sl.shapes if hasattr(sh, "text") and sh.text.strip()]) for i, sl in enumerate(pptx.Presentation(filepath).slides)])
             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)"
+                return f"[Image: {Path(filepath).name}]\nFormat: {img.format}\nDimensions: {img.size[0]}x{img.size[1]}\nMode: {img.mode}"
             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)}]"
+                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}]"
-        
+        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'})
+        resp = session.get(f"https://html.duckduckgo.com/html/?q={urllib.parse.quote(query)}", 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}")
-        
+        results = [a.get_text(strip=True) for a in soup.find_all('a', class_='result__snippet', limit=max_results) if a.get_text(strip=True)]
         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)}]"
+                if snippet: results.append(snippet.get_text(strip=True))
+        return "\n---\n".join([f"Result: {r}" for r in results]) if results else "[SCRAPE_FAILED: No text found]"
+    except Exception as e: return f"[SCRAPE_FAILED: {str(e)}]"
 
 class CavemanMode(Enum):
     OFF = 0; BASIC = 1; ULTRA = 2
@@ -270,8 +331,7 @@ class FileSystemManager:
 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)
+        self.active_processes = {}
     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)
@@ -279,20 +339,66 @@ class CommandRunner:
             return result.returncode == 0, output
         except subprocess.TimeoutExpired: return False, "Command timed out"
         except Exception as e: return False, f"Error: {str(e)}"
+    
+    def execute_script(self, filepath: str) -> Tuple[bool, str]:
+        """Execute a script file, opening a side terminal on Windows."""
+        full_path = os.path.join(self.workspace_dir, filepath)
+        if not os.path.exists(full_path): return False, f"File not found: {filepath}"
+        
+        ext = Path(filepath).suffix.lower()
+        commands = {
+            '.py': f'python "{full_path}"', '.js': f'node "{full_path}"', '.ts': f'ts-node "{full_path}"',
+            '.java': f'java -cp "{self.workspace_dir}" {Path(filepath).stem}', '.go': f'go run "{full_path}"',
+            '.rs': f'rustc "{full_path}" && {Path(filepath).stem}', '.sh': f'bash "{full_path}"',
+            '.bat': f'"{full_path}"', '.ps1': f'powershell -ExecutionPolicy Bypass -File "{full_path}"'
+        }
+        
+        if ext not in commands: return False, f"Unsupported script type: {ext}"
+        cmd = commands[ext]
+        
+        if sys.platform == 'win32':
+            process = subprocess.Popen(f'start cmd /k {cmd}', shell=True, cwd=self.workspace_dir)
+        else:
+            process = subprocess.Popen(cmd, shell=True, cwd=self.workspace_dir, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+        self.active_processes[filepath] = process
+        return True, f"✅ Script opened in side terminal. Command: {cmd}"
+    
+    def check_process(self, filepath: str) -> str:
+        if filepath not in self.active_processes: return "No active process for this file."
+        process = self.active_processes[filepath]
+        if process.poll() is None: return "🔄 Still running..."
+        return f"✅ Process finished with return code: {process.returncode}"
+    
+    def execute_notebook(self, filepath: str) -> Tuple[bool, str]:
+        """Execute a Jupyter notebook and save with outputs."""
+        full_path = os.path.join(self.workspace_dir, filepath)
+        if not os.path.exists(full_path): return False, f"Notebook not found: {filepath}"
+        
+        try:
+            import nbformat
+            from nbconvert.preprocessors import ExecutePreprocessor
+            with open(full_path, 'r', encoding='utf-8') as f: nb = nbformat.read(f, as_version=4)
+            ep = ExecutePreprocessor(timeout=600, kernel_name='python3')
+            ep.preprocess(nb, {'metadata': {'path': self.workspace_dir}})
+            with open(full_path, 'w', encoding='utf-8') as f: nbformat.write(nb, f)
+            return True, f"✅ Notebook executed successfully. Outputs saved to {filepath}"
+        except Exception as e: return False, f"Notebook execution failed: {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
+        except: 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"
+        except: 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 ""
+        except: return ""
     def check_github_auth(self) -> Dict[str, Any]:
         result = {"logged_in": False, "user": "", "method": ""}
         try:
@@ -305,13 +411,13 @@ class GitManager:
                         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
+        except: 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
+        except: pass
         return result
     def get_status(self) -> Dict[str, Any]:
         if not self.is_repo(): return {"error": "Not a git repository"}
@@ -339,7 +445,7 @@ class GitManager:
     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 []
+        except: 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)
@@ -405,7 +511,7 @@ class AIModelClient:
                         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
+                except: 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
@@ -432,7 +538,7 @@ class AIModelClient:
                 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
+        except: 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))
@@ -478,8 +584,11 @@ class AIModelClient:
             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 = ""
+        in_code_block = False
+        buffer = ""
         try:
             for line in resp.iter_lines():
                 if not line: continue
@@ -503,9 +612,24 @@ class AIModelClient:
                 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
+                    buffer += content
+                    
+                    if "```" in buffer:
+                        parts = buffer.split("```", 1)
+                        if not in_code_block and parts[0].strip():
+                            console.print(parts[0], end="", markup=False, highlight=False)
+                        in_code_block = not in_code_block
+                        if in_code_block:
+                            console.print("\n[bold cyan]✨ Generating code...[/bold cyan]", end="", markup=False)
+                        else:
+                            console.print("\n", end="", markup=False)
+                        buffer = parts[1]
+                    elif not in_code_block:
+                        console.print(buffer, end="", markup=False, highlight=False)
+                        buffer = ""
         except Exception as e: console.print(f"\n[red]Stream error: {str(e)}[/red]")
         console.print()
         return full_response
@@ -515,18 +639,35 @@ class SamCodeCLI:
         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")
+        self.memory_path = os.path.join(self.config_dir, "session_memory.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.frontend_mode = False
+        self.data_mode = False
+        self.data_session = {"datasets": {}, "analysis_steps": [], "agreed_notebook": None}
         self.session_context = [] 
+        
+        self.session_history = []
+        if os.path.exists(self.memory_path):
+            try:
+                with open(self.memory_path, 'r') as f: self.session_history = json.load(f)
+            except: pass
+        
         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.memory = CodebaseMemory(self.workspace_dir)
+        self.memory.index_workspace(self.file_manager)
+        self.code_doctor = CodeDoctor(self.workspace_dir)
+        
+        self.command_completer = WordCompleter(['/connect', '/models', '/upload', '/clear-uploads', '/caveman', '/frontend', '/data', '/reindex', '/clear-memory', '/clear', '/exit', '/help', '/aboutme', '/searchweb', '/git'], sentence=True)
         self.prompt_text = FormattedText([('ansicyan bold', '❯ ')])
         self.load_configuration()
 
@@ -541,11 +682,16 @@ class SamCodeCLI:
                     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
+                    self.frontend_mode = data.get("frontend_mode", False)
             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)
+            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, "frontend_mode": self.frontend_mode}, f, indent=2)
+            
+    def save_session_memory(self):
+        self.session_history = self.session_history[-20:]
+        with open(self.memory_path, "w") as f: json.dump(self.session_history, f, indent=2)
     
     def get_client(self) -> Optional[AIModelClient]:
         provider_config = self.provider_registry.get_provider(self.active_provider)
@@ -553,20 +699,44 @@ class SamCodeCLI:
         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)
 
+    # ✅ NEW: Auto-ignore dotfiles
+    def auto_ignore_dotfiles(self):
+        gitignore_path = os.path.join(self.workspace_dir, ".gitignore")
+        dotfiles_to_ignore = []
+        for item in os.listdir(self.workspace_dir):
+            if item.startswith('.') and item not in ['.git', '.gitignore']:
+                full_path = os.path.join(self.workspace_dir, item)
+                entry = f"{item}/" if os.path.isdir(full_path) else item
+                dotfiles_to_ignore.append(entry)
+        if ".samcode/" not in dotfiles_to_ignore: dotfiles_to_ignore.append(".samcode/")
+
+        content = ""
+        if os.path.exists(gitignore_path):
+            with open(gitignore_path, "r") as f: content = f.read()
+
+        new_entries = [e for e in dotfiles_to_ignore if e not in content]
+        if new_entries:
+            with open(gitignore_path, "a") as f:
+                f.write("\n# Auto-ignored dotfiles by SamCode CLI\n")
+                for entry in new_entries: f.write(f"{entry}\n")
+            console.print(f"[green]✓ Automatically added {len(new_entries)} config file(s) to .gitignore[/green]")
+
     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)))
+        git_indicator = f" | [yellow]🌿 {self.git_manager.get_current_branch()}[/yellow]" if self.git_manager.is_repo() else ""
+        frontend_indicator = " | [bold magenta]🎨 FRONTEND[/bold magenta]" if self.frontend_mode else ""
+        data_indicator = " | [bold cyan]📊 DATA[/bold cyan]" if self.data_mode else ""
+            
+        header_table.add_row("⚡ SamCode CLI", "Autonomous Coding Agent", f"{self.active_provider} | {self.active_model[:15]}{caveman_indicator}{upload_indicator}{git_indicator}{frontend_indicator}{data_indicator}")
+        path_text = Text(f" Workspace: {self.workspace_dir}", style="dim italic")
+        console.print(Panel(Group(header_table, path_text), border_style="bright_black", padding=(0, 2)))
         console.print("[dim]Type your request naturally, or use /help for commands.[/dim]\n")
 
     def cmd_connect(self):
@@ -578,14 +748,13 @@ class SamCodeCLI:
         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]")
+        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")
+        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]")
@@ -617,7 +786,7 @@ class SamCodeCLI:
                     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: console.print("[yellow]⚠️ Already on the first page.[/yellow]")
                 else:
                     try:
                         idx = int(user_input) - 1
@@ -633,6 +802,54 @@ class SamCodeCLI:
         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_frontend(self):
+        self.frontend_mode = not self.frontend_mode
+        self.save_configuration()
+        if self.frontend_mode:
+            msg = "[bold magenta]🎨 FRONTEND ARCHITECT MODE: ON[/bold magenta]\n"
+            msg += "[dim]AI will now act as a senior frontend developer with unique design systems, custom palettes, and performance-first architecture.[/dim]"
+        else:
+            msg = "[bold cyan]⚙️  FRONTEND ARCHITECT MODE: OFF[/bold cyan]\n"
+            msg += "[dim]Returning to standard coding assistant behavior.[/dim]"
+        console.print(f"\n{msg}\n")
+        self.show_main_header()
+
+    def cmd_data(self):
+        self.data_mode = not self.data_mode
+        if self.data_mode:
+            msg = "[bold cyan] DATA ANALYST MODE: ON[/bold cyan]\n"
+            msg += "[dim]Agent is now a Senior BI Analyst. Ready to read datasets, generate insights, create charts, and build production-ready Jupyter Notebooks with markdown documentation.[/dim]"
+            console.print(f"\n{msg}\n")
+        else:
+            msg = "[bold green]✅ DATA ANALYST MODE: OFF[/bold green]\n"
+            msg += "[dim]Returning to standard coding assistant behavior.[/dim]"
+            if self.data_session.get("agreed_notebook"): self._save_notebook(self.data_session["agreed_notebook"])
+            console.print(f"\n{msg}\n")
+        self.show_main_header()
+
+    def _save_notebook(self, notebook_content: dict):
+        import nbformat
+        nb = nbformat.v4.new_notebook()
+        nb.cells.append(nbformat.v4.new_markdown_cell("# 📊 Automated Data Analysis Report\n*Generated by SamCode CLI Data Analyst Mode*"))
+        for step in self.data_session["analysis_steps"]:
+            nb.cells.append(nbformat.v4.new_markdown_cell(f"## {step['title']}\n{step['description']}"))
+            nb.cells.append(nbformat.v4.new_code_cell(step['code']))
+        filename = f"data_analysis_{int(time.time())}.ipynb"
+        filepath = os.path.join(self.workspace_dir, filename)
+        with open(filepath, 'w') as f: nbformat.write(nb, f)
+        console.print(f"[green]✓ Saved professional notebook: {filename}[/green]")
+
+    def cmd_reindex(self):
+        console.print("[cyan]🔄 Re-indexing codebase memory...[/cyan]")
+        self.memory._is_indexed = False
+        self.memory.index_workspace(self.file_manager)
+        console.print("[green]✓ Re-indexing complete.[/green]\n")
+
+    def cmd_clear_memory(self):
+        self.session_history = []
+        self.save_session_memory()
+        console.print("[yellow]️ Session memory cleared. The agent will forget previous goals.[/yellow]\n")
+
     def cmd_upload(self, filepath: str = ""):
         if not filepath: filepath = Prompt.ask("[cyan]Enter file path to upload[/cyan]").strip()
         if not filepath: return
@@ -690,7 +907,6 @@ class SamCodeCLI:
             {"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()
@@ -710,7 +926,7 @@ class SamCodeCLI:
         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")]
+        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)
@@ -726,28 +942,13 @@ class SamCodeCLI:
         self.show_main_header()
 
     def _initialize_git_repo(self):
-        console.print("\n[bold cyan] Initialize Git Repository[/bold cyan]\n")
+        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")
-        # ----------------------------------------
+        # ✅ NEW: Automatically ignore all dotfiles
+        self.auto_ignore_dotfiles()
 
         try:
             user_check = subprocess.run(["git", "config", "user.name"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=5)
@@ -757,7 +958,7 @@ class SamCodeCLI:
                 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
+        except: 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
@@ -817,7 +1018,7 @@ class SamCodeCLI:
         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)
+        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")
@@ -866,12 +1067,12 @@ class SamCodeCLI:
             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")
+        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")
+        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)
@@ -897,7 +1098,7 @@ class SamCodeCLI:
             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")
+        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()
@@ -914,18 +1115,86 @@ class SamCodeCLI:
             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 _detect_data_intent(self, prompt: str) -> bool:
+        data_keywords = ['analyze', 'plot', 'chart', 'graph', 'visualize', 'trend', 'correlation', 'distribution', 'histogram', 'scatter', 'heatmap', 'dataset', 'csv', 'excel', 'database', 'sql', 'bi ', 'dashboard', 'kpi', 'metric', 'aggregate', 'groupby', 'pivot']
+        return any(kw in prompt.lower() for kw in data_keywords)
+
     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
+        if not client or not self.api_key: 
+            console.print("[red]Configure AI first with /connect[/red]")
+            return
+        
+        proactive_findings = ""
+        if self.code_doctor.should_analyze(question):
+            console.print("[cyan]🩺 Code Doctor: Analyzing project for issues...[/cyan]")
+            relevant_files = self.code_doctor.get_relevant_files(question, self.file_manager, getattr(self, 'memory', None))
+            if relevant_files:
+                findings = self.code_doctor.run_analysis(relevant_files)
+                if findings:
+                    proactive_findings = "\n\n🩺 PROACTIVE CODE ANALYSIS FINDINGS:\n"
+                    for filepath, report in findings.items(): proactive_findings += report
+                    console.print(f"[green]✓ Found issues in {len(findings)} file(s). Injecting into context.[/green]")
+                else: console.print("[yellow]️ No linting issues found. Proceeding normally.[/yellow]")
+            else: console.print("[yellow]⚠️ Could not determine relevant files to analyze.[/yellow]")
+        
         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"
+            context_str = "\n\nUPLOADED DOCUMENTS CONTEXT:\n"
             for doc in self.session_context: context_str += f"=== {doc['filename']} ===\n{doc['content']}\n\n"
+        if proactive_findings: context_str += proactive_findings
+        
+        token_economy_rule = """
+9. CRITICAL SYSTEM RULE: NEVER output markdown code blocks (```python ... ```) in your chat response. 
+   - If you output a code block, the UI will crash. 
+   - Instead, you MUST say ONLY: "✨ Generating [filename]..." or "📖 Reading [filename]...". 
+   - Actual code MUST be placed inside [WRITE_FILE] tags. 
+   - Actual file content MUST come from [READ_FILE] tool results.
+   - To execute a script, use [EXECUTE_SCRIPT: <path>].
+   - To execute a notebook, use [EXECUTE_NOTEBOOK: <path>].
+"""
+        
+        frontend_rules = ""
+        if self.frontend_mode:
+            frontend_rules = """
+10. 🎨 EXPERT FRONTEND DEVELOPER MODE IS ACTIVE: You are NOT an AI coding assistant. You are a Senior Frontend Architect & Design Systems Engineer.
+    - NEVER use generic AI styling patterns (no default blue/gray palettes, no Inter/Roboto/Arial fonts, no basic Tailwind utility soup).
+    - ALWAYS analyze the project's subject matter FIRST. Derive a completely unique, bespoke design system from scratch based on the brand identity, target audience, and emotional tone of the project.
+    - Create custom CSS variables or theme tokens for colors, typography, spacing, and shadows. Define these BEFORE writing any component code.
+    - Prioritize modern, performant web standards (CSS Container Queries, :has(), native nesting, view transitions API, subgrid). Avoid outdated patterns.
+    - When generating UI, explain your DESIGN RATIONALE first (why this palette? why this type scale? why this layout pattern?), THEN provide the implementation.
+    - Treat every project as a unique product requiring a tailored visual language. Your output should look like it was crafted by a human design engineer, not generated by an LLM.
+"""
+
+        data_analyst_rules = ""
+        is_data_task = self.data_mode or self._detect_data_intent(question)
+        if is_data_task:
+            if self.caveman_mode != CavemanMode.OFF:
+                data_analyst_rules = """
+11.  DATA ANALYST MODE (CAVEMAN ACTIVE): 
+    - NO explanations. NO business insights. NO markdown formatting for text.
+    - Output ONLY raw code, chart generation scripts, or direct answers.
+    - If asked to analyze, return ONLY the Python/pandas/seaborn code block. Nothing else.
+    - Do NOT describe what you are doing. Just output the tool call or code.
+"""
+            else:
+                data_analyst_rules = """
+11. 📊 SENIOR DATA ANALYST & BI EXPERT MODE ACTIVE:
+    - You are NOT just a coder. You are a Senior Business Intelligence Analyst.
+    - ALWAYS start by reading the dataset using [RUN_TERMINAL: python -c "..."] or providing Python code to load it via UniversalDataReader.
+    - Before writing ANY code, EXPLAIN your analytical approach: What KPIs matter? What business questions are we answering?
+    - Generate publication-quality visualizations using seaborn/matplotlib. Always include titles, axis labels, and legends.
+    - Provide actionable business insights, not just statistical observations. Connect data patterns to real-world business outcomes.
+    - When the user agrees on an analysis workflow, PROACTIVELY offer to save it as a production-ready Jupyter Notebook (.ipynb) with detailed markdown cells explaining each step, methodology, and business context.
+    - Support ALL data formats: CSV, Excel, Parquet, Feather, JSON, HDF5, PostgreSQL, MySQL, SQLite, MSSQL, and any SQLAlchemy-compatible data warehouse.
+"""
+
         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."
+        if self.caveman_mode == CavemanMode.BASIC: caveman_rules = "\n12. 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 = "\n12. CAVEMAN MODE (ULTRA) IS ACTIVE: MAXIMUM TOKEN SAVING. Output ONLY code/tool calls. Zero explanations. Zero 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}
 
@@ -939,28 +1208,55 @@ You have access to the following tools to help you complete tasks:
 [END_WRITE_FILE]
 [RUN_TERMINAL: <command>]
 [SEARCH_CODE: <query>]
+[SEARCH_SEMANTIC: <natural_language_query>]
+[EXECUTE_SCRIPT: <path>]
+[EXECUTE_NOTEBOOK: <path>]
+[CHECK_PROCESS: <path>]
 
 CRITICAL RULES:
-1. You have full access to the workspace. NEVER say you cannot access files.
+1. You have full access to the workspace. NEVER say you cannot access files or execute commands.
 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}]
+7. If you need to run a terminal command (like git push, npm install, python main.py), use [RUN_TERMINAL: <command>].
+8. If the user asks about functionality, architecture, concepts, or where something is implemented (e.g., "how does auth work?", "find the payment logic", "where is the database configured"), ALWAYS use [SEARCH_SEMANTIC: <descriptive_natural_query>] FIRST before reading any files. This finds relevant code even if variable names differ.
+9. Only use [READ_FILE] after [SEARCH_SEMANTIC] returns specific file paths.
+10. To execute a script file (Python, Node.js, etc.), use [EXECUTE_SCRIPT: <path>]. This opens a side terminal showing execution.
+11. To execute a Jupyter notebook, use [EXECUTE_NOTEBOOK: <path>]. This runs all cells and saves outputs.
+12. To check if a script is still running, use [CHECK_PROCESS: <path>].{token_economy_rule}{frontend_rules}{data_analyst_rules}{caveman_rules}"""
+        
+        recent_history = self.session_history[-10:] 
+        messages = [{"role": "system", "content": system_msg}]
+        messages.extend(recent_history)
+        
+        caveman_reminder = ""
+        if self.caveman_mode == CavemanMode.BASIC:
+            caveman_reminder = "\n\n[SYSTEM REMINDER: CAVEMAN BASIC ACTIVE. Be extremely concise. No fluff. Short sentences only.]"
+        elif self.caveman_mode == CavemanMode.ULTRA:
+            caveman_reminder = "\n\n[SYSTEM REMINDER: CAVEMAN ULTRA ACTIVE. MAXIMUM TOKEN SAVING. Output ONLY code/tool calls. Zero explanations. Zero greetings. Grunt-like brevity.]"
+
+        messages.append({"role": "user", "content": question + caveman_reminder})
+        
         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
+                
+                self.session_history.append({"role": "user", "content": question})
+                self.session_history.append({"role": "assistant", "content": response})
+                self.save_session_memory()
+                
                 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)
+                single_match = re.search(r'\[(READ_FILE|RUN_TERMINAL|SEARCH_CODE|SEARCH_SEMANTIC|EXECUTE_SCRIPT|EXECUTE_NOTEBOOK|CHECK_PROCESS):\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'
@@ -970,28 +1266,49 @@ CRITICAL RULES:
                         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}."
+                            self.file_manager.write_file(path, content)
+                            # ✅ NEW: Auto-ignore dotfiles
+                            if path.startswith('.'): self.auto_ignore_dotfiles()
+                            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}."
+                        self.file_manager.write_file(path, content)
+                        # ✅ NEW: Auto-ignore dotfiles
+                        if path.startswith('.'): self.auto_ignore_dotfiles()
+                        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":
+                    
+                    if tool_name == "SEARCH_SEMANTIC":
+                        results = self.memory.search(tool_arg)
+                        if not results: tool_result = "No semantically relevant code found in the codebase."
+                        else:
+                            formatted = []
+                            for r in results:
+                                snippet_preview = r['snippet'][:300].replace('\n', ' ') + "..." if len(r['snippet']) > 300 else r['snippet'].replace('\n', ' ')
+                                formatted.append(f"📄 {r['file']}:\n{snippet_preview}")
+                            tool_result = "\n\n---\n\n".join(formatted)
+                        console.print(f"\n[blue]🧠 Semantic Search: '{tool_arg}'[/blue]")
+                        tool_executed = True
+                        
+                    elif 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
+                        console.print(f"\n[blue]📖 Reading {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):
@@ -1001,6 +1318,35 @@ CRITICAL RULES:
                             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
+                        
+                    elif tool_name == "EXECUTE_SCRIPT":
+                        console.print(f"\n[bold cyan]🚀 Executing script: {tool_arg}[/bold cyan]")
+                        success, output = self.command_runner.execute_script(tool_arg)
+                        tool_result = output
+                        if success:
+                            console.print(f"[green]✓ {output}[/green]")
+                            console.print("[dim]The script is running in a side terminal. Use [CHECK_PROCESS: <path>] to verify completion.[/dim]")
+                        else: console.print(f"[red]✗ {output}[/red]")
+                        tool_executed = True
+                        
+                    elif tool_name == "EXECUTE_NOTEBOOK":
+                        console.print(f"\n[bold cyan]📓 Executing notebook: {tool_arg}[/bold cyan]")
+                        console.print("[cyan]Running all cells and saving outputs...[/cyan]")
+                        success, output = self.command_runner.execute_notebook(tool_arg)
+                        tool_result = output
+                        if success:
+                            console.print(f"[green]✓ {output}[/green]")
+                            console.print("[dim]Open the notebook in Jupyter/VS Code to see execution results in cells.[/dim]")
+                        else: console.print(f"[red]✗ {output}[/red]")
+                        tool_executed = True
+                        
+                    elif tool_name == "CHECK_PROCESS":
+                        console.print(f"\n[bold cyan] Checking process: {tool_arg}[/bold cyan]")
+                        output = self.command_runner.check_process(tool_arg)
+                        tool_result = output
+                        console.print(f"[cyan]{output}[/cyan]")
+                        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."})
@@ -1010,7 +1356,22 @@ CRITICAL RULES:
 
     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"}
+        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)", 
+            "/frontend": "Toggle expert frontend architect mode (unique design systems)",
+            "/data": "Toggle professional data analyst & BI mode (notebooks, charts, SQL)",
+            "/reindex": "Re-build vector memory index after code changes",
+            "/clear-memory": "Clear session conversation history",
+            "/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")
 
@@ -1022,7 +1383,6 @@ CRITICAL RULES:
             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, 
@@ -1037,6 +1397,10 @@ CRITICAL RULES:
                 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 ["/frontend"]: self.cmd_frontend()
+                elif user_input.lower() in ["/data"]: self.cmd_data()
+                elif user_input.lower() in ["/reindex"]: self.cmd_reindex()
+                elif user_input.lower() in ["/clear-memory"]: self.cmd_clear_memory()
                 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"):

{samcode_cli-1.0.3.dist-info → samcode_cli-1.0.5.dist-info}/METADATA

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

samcode_cli-1.0.5.dist-info/RECORD

@@ -0,0 +1,6 @@
+samcode.py,sha256=pUXCqCAbuUBZ-oyvrag1XkMioqaCcYfGMFgYCiu9V9o,92199
+samcode_cli-1.0.5.dist-info/METADATA,sha256=WApOF2ZDT7_wqWvySRToO0YfsHdRC9ELAcutaePSxuI,6269
+samcode_cli-1.0.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+samcode_cli-1.0.5.dist-info/entry_points.txt,sha256=pTSNSMG9LYqLdbOR0TZGIQS0I17ZEUdXLEapLCYmyqo,41
+samcode_cli-1.0.5.dist-info/top_level.txt,sha256=ie3RFdU_m6daHft-jFl_UKNkKAA25CItx4-gyRRHbJY,8
+samcode_cli-1.0.5.dist-info/RECORD,,

samcode_cli-1.0.3.dist-info/RECORD

@@ -1,6 +0,0 @@
-samcode.py,sha256=1CjVOavyAwvIHXwlDBfKsbJr4bWI2c_BYdI4TMU702k,70036
-samcode_cli-1.0.3.dist-info/METADATA,sha256=nNxnlmmVbKo-_JMukTvomKxidoBQKll6iQmTlsApVeg,6269
-samcode_cli-1.0.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-samcode_cli-1.0.3.dist-info/entry_points.txt,sha256=pTSNSMG9LYqLdbOR0TZGIQS0I17ZEUdXLEapLCYmyqo,41
-samcode_cli-1.0.3.dist-info/top_level.txt,sha256=ie3RFdU_m6daHft-jFl_UKNkKAA25CItx4-gyRRHbJY,8
-samcode_cli-1.0.3.dist-info/RECORD,,