samcode-cli 1.0.4__tar.gz → 1.0.5__tar.gz

{samcode_cli-1.0.4/samcode_cli.egg-info → samcode_cli-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: samcode-cli
-Version: 1.0.4
+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.4 → samcode_cli-1.0.5}/samcode.py

@@ -2,9 +2,8 @@
 """
 ╔══════════════════════════════════════════════════════════════════════════════╗
 ║                          S A M C O D E   C L I                              ║
-║                   Autonomous Coding Agent v6.2 (RAG + Doctor + Data BI)     ║
-║              Similar to Claude Code & GitHub Copilot Workspace              ║
-╚══════════════════════════════════════════════════════════════════════════════╝
+║                   Autonomous Coding Agent v6.5 (Full Integration)           ║
+══════════════════════════════════════════════════════════════════════════════╝
 """
 
 import os
@@ -15,12 +14,17 @@ 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
+# 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
@@ -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
@@ -47,35 +50,24 @@ except ImportError:
     from prompt_toolkit.formatted_text import FormattedText
     from prompt_toolkit.styles import Style
     from prompt_toolkit.enums import EditingMode
-import warnings
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-warnings.filterwarnings("ignore", message=".*urllib3.*")
 
-# HTTP Client
 try:
     import requests
 except ImportError:
     subprocess.run([sys.executable, "-m", "pip", "install", "requests", "-q"], capture_output=True)
     import requests
 
-
+# ✅ FIX: Define console BEFORE the auto-installer loop
 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',
-})
-
-# Document Processing & Web Parsing Libraries Auto-Install
-# Document Processing & Web Parsing Libraries Auto-Install
 LIBS_TO_INSTALL = {
     'pdfplumber': 'pdfplumber', 'docx': 'python-docx', 'openpyxl': 'openpyxl',
     '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'
+    'pyarrow': 'pyarrow', 'psycopg2_binary': 'psycopg2-binary', 'pymysql': 'pymysql',
+    'nbconvert': 'nbconvert'
 }
 
 for module, package in LIBS_TO_INSTALL.items():
@@ -83,257 +75,140 @@ for module, package in LIBS_TO_INSTALL.items():
         __import__(module)
     except ImportError:
         console.print(f"[cyan]Installing {package}...[/cyan]")
-        # ✅ FIX: Use subprocess with explicit error checking
-        result = subprocess.run(
-            [sys.executable, "-m", "pip", "install", "--no-cache-dir", package], 
-            capture_output=True, text=True
-        )
-        if result.returncode != 0:
-            console.print(f"[red]⚠️ Failed to install {package}. Run manually: pip install {package}[/red]")
-            console.print(f"[dim]{result.stderr[:200]}[/dim]")
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# KEYBOARD SHORTCUTS FOR PROMPT (Only custom ones)
-# ═══════════════════════════════════════════════════════════════════════════════
+        subprocess.run([sys.executable, "-m", "pip", "install", "--no-cache-dir", package], capture_output=True)
 
-from prompt_toolkit.key_binding import KeyBindings
+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',
+})
 
+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)
 
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# VECTOR-BASED CODEBASE MEMORY (RAG)
-# ═══════════════════════════════════════════════════════════════════════════════
-
 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)
-    
-        # ✅ LAZY LOAD: Only import when actually needed
+        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.collection = self.client.get_or_create_collection(name="codebase", metadata={"hnsw:space": "cosine"})
             self.model = SentenceTransformer('all-MiniLM-L6-v2')
-            self._is_indexed = False
         except Exception as e:
-            console.print(f"[yellow]⚠️ Vector memory unavailable: {str(e)[:80]}...[/yellow]")
-            console.print("[dim]Run: pip install sentence-transformers transformers 'numpy<2'[/dim]")
-            self._is_indexed = True  # Prevents repeated crash attempts
+            console.print(f"[yellow]⚠️ Vector memory unavailable. Run: pip install 'numpy<2' torch transformers sentence-transformers[/yellow]")
 
-    def index_workspace(self, file_manager: 'FileSystemManager'):
-        """Scan and embed all code files in the workspace."""
-        if self._is_indexed:
-            return
-            
+    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 = []
-        
+        docs, ids, metadatas = [], [], []
         code_extensions = {'.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs', '.html', '.css', '.scss', '.sql', '.sh'}
         
         for f in files:
-            ext = Path(f).suffix.lower()
-            if ext in code_extensions:
+            if Path(f).suffix.lower() in code_extensions:
                 content = file_manager.read_file(f)
-                if content and len(content) < 10000:  # Skip huge files
+                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": ext})
+                    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
-            )
+            self.collection.upsert(documents=docs, embeddings=embeddings, ids=ids, metadatas=metadatas)
             console.print(f"[green]✓ Indexed {len(docs)} files into vector memory.[/green]")
-        else:
-            console.print("[yellow]⚠️ No code files found to index.[/yellow]")
-        
         self._is_indexed = True
 
     def search(self, query: str, n_results: int = 3) -> List[Dict]:
-        """Find semantically relevant code snippets."""
+        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])
-        ]
-
+        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])]
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# PROACTIVE CODE DOCTOR
-# ═══════════════════════════════════════════════════════════════════════════════
 
 class CodeDoctor:
-    """Automatically analyzes code when user mentions bugs, optimization, or cleanup."""
+    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']
     
-    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 __init__(self, workspace_dir: str): self.workspace_dir = workspace_dir
     def should_analyze(self, user_prompt: str) -> bool:
-        """Check if user's natural language implies code analysis is needed."""
-        prompt_lower = user_prompt.lower()
-        return any(keyword in prompt_lower for keyword in self.INTENT_KEYWORDS)
+        return any(kw in user_prompt.lower() for kw in self.INTENT_KEYWORDS)
     
-    def get_relevant_files(self, user_prompt: str, file_manager: 'FileSystemManager', memory: Optional['CodebaseMemory'] = None) -> List[str]:
-        """Determine which files to analyze based on user intent."""
-        # Try semantic search first if available
-        if memory:
+    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]
-        
-        # Fallback: extract filenames mentioned in prompt
+            if results: return [r['file'] for r in results]
         files = file_manager.scan_workspace(max_files=100)
-        mentioned = []
-        for f in files:
-            basename = Path(f).stem
-            if basename.lower() in user_prompt.lower() or f.lower() in user_prompt.lower():
-                mentioned.append(f)
-        
-        # If no specific files mentioned, analyze key files
-        if not mentioned:
-            key_files = [f for f in files if any(ext in f for ext in ['.py', '.js', '.ts', '.jsx', '.tsx'])][:10]
-            return key_files
-            
-        return mentioned[:10]  # Limit to avoid overwhelming context
+        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]:
-        """Run static analysis on specified files and return findings."""
         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
-                
+            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
-                    )
+                    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]:  # Limit per file
-                                row = issue.get('location', {}).get('row', '?')
-                                code = issue.get('code', '')
-                                msg = issue.get('message', '')
-                                summary += f"  • Line {row}: [{code}] {msg}\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 (subprocess.TimeoutExpired, FileNotFoundError, Exception):
-                # Silently skip if tool isn't installed or fails
-                pass
-                
+            except: pass
         return findings
 
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# UNIVERSAL DATA READER
-# ═══════════════════════════════════════════════════════════════════════════════
-
 class UniversalDataReader:
-    """Reads datasets from any source: CSV, Excel, Parquet, SQL, NoSQL, or Cloud Warehouses."""
-    
-    SUPPORTED_EXTENSIONS = {'.csv', '.xlsx', '.xls', '.parquet', '.feather', '.json', '.hdf5'}
-    
     @staticmethod
     def read(source: str, **kwargs) -> Tuple[Any, str]:
         import pandas as pd
-        
-        # Handle Database / Data Warehouse Connections
         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)
-                meta = f"🗄️ Database Source: {source.split('@')[-1]}\nQuery executed successfully."
-                return df, meta
-            except Exception as e:
-                return None, f"[DB_ERROR] Failed to connect/query: {str(e)}"
+                return df, f"🗄️ Database Source: {source.split('@')[-1]}\nQuery executed successfully."
+            except Exception as e: return None, f"[DB_ERROR] {str(e)}"
 
-        # Handle Local Files
         ext = Path(source).suffix.lower()
-        
         try:
-            if ext == '.csv':
-                df = pd.read_csv(source, **kwargs)
-            elif ext in ['.xlsx', '.xls']:
-                sheet = kwargs.get('sheet_name', 0)
-                df = pd.read_excel(source, sheet_name=sheet, **kwargs)
-            elif ext == '.parquet':
-                df = pd.read_parquet(source, **kwargs)
-            elif ext == '.feather':
-                df = pd.read_feather(source, **kwargs)
-            elif ext == '.json':
-                orient = kwargs.get('orient', 'columns')
-                df = pd.read_json(source, orient=orient, **kwargs)
-            elif ext == '.hdf5':
-                key = kwargs.get('key')
-                if not key: raise ValueError("HDF5 requires a 'key' parameter")
-                df = pd.read_hdf(source, key=key, **kwargs)
-            else:
-                return None, f"[UNSUPPORTED] Extension '{ext}' is not supported."
-                
-            # Generate rich metadata for the LLM
-            meta = (
-                f"📊 Dataset: {Path(source).name}\n"
-                f"Rows: {len(df):,} | Columns: {len(df.columns)}\n"
-                f"Dtypes:\n{df.dtypes.to_dict()}\n"
-                f"Missing Values:\n{df.isnull().sum().to_dict()}\n"
-                f"First 3 Rows Preview:\n{df.head(3).to_markdown()}"
-            )
+            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)}"
+        except Exception as e: return None, f"[READ_ERROR] {str(e)}"
 
 
 class DocumentReader:
@@ -343,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
@@ -504,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)
@@ -513,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:
@@ -539,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"}
@@ -573,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)
@@ -639,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
@@ -666,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))
@@ -712,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
@@ -737,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
@@ -749,7 +639,9 @@ 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"
@@ -757,21 +649,25 @@ class SamCodeCLI:
         self.custom_base_url = ""
         self.caveman_mode = CavemanMode.OFF
         self.frontend_mode = False
-        self.data_mode = False  # NEW: Professional Data Analyst Mode
-        self.data_session = {"datasets": {}, "analysis_steps": [], "agreed_notebook": None}  # NEW: Data Session State
+        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)
         
-        # Initialize Vector Memory
         self.memory = CodebaseMemory(self.workspace_dir)
         self.memory.index_workspace(self.file_manager)
-        
-        # Initialize Proactive Code Doctor
         self.code_doctor = CodeDoctor(self.workspace_dir)
         
-        self.command_completer = WordCompleter(['/connect', '/models', '/upload', '/clear-uploads', '/caveman', '/frontend', '/data', '/reindex', '/clear', '/exit', '/help', '/aboutme', '/searchweb', '/git'], sentence=True)
+        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()
 
@@ -791,14 +687,11 @@ class SamCodeCLI:
     
     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,
-                "frontend_mode": self.frontend_mode
-            }, 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)
@@ -806,9 +699,30 @@ 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")
@@ -816,23 +730,13 @@ class SamCodeCLI:
         
         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]"
-        frontend_indicator = " | [bold magenta]🎨 FRONTEND ARCHITECT[/bold magenta]" if self.frontend_mode else ""
-        data_indicator = " | [bold cyan]📊 DATA ANALYST[/bold cyan]" if self.data_mode else ""
+        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")
-        combined_content = Group(header_table, path_text)
-        
-        console.print(Panel(combined_content, border_style="bright_black", padding=(0, 2)))
+        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):
@@ -844,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]")
@@ -883,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
@@ -911,42 +814,29 @@ class SamCodeCLI:
         console.print(f"\n{msg}\n")
         self.show_main_header()
 
-    # NEW: Professional Data Analyst Mode Toggle
     def cmd_data(self):
-        """Toggle Professional Data Analyst & BI Mode."""
         self.data_mode = not self.data_mode
-        
         if self.data_mode:
-            msg = "[bold cyan]📊 DATA ANALYST MODE: ON[/bold cyan]\n"
+            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]"
-            # Save agreed notebook if exists when exiting mode
-            if self.data_session.get("agreed_notebook"):
-                self._save_notebook(self.data_session["agreed_notebook"])
+            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):
-        """Saves the agreed-upon analysis as a .ipynb file with rich markdown cells."""
         import nbformat
         nb = nbformat.v4.new_notebook()
-        
-        # Add title cell
         nb.cells.append(nbformat.v4.new_markdown_cell("# 📊 Automated Data Analysis Report\n*Generated by SamCode CLI Data Analyst Mode*"))
-        
-        # Add agreed steps as markdown + code cells
         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)
+        with open(filepath, 'w') as f: nbformat.write(nb, f)
         console.print(f"[green]✓ Saved professional notebook: {filename}[/green]")
 
     def cmd_reindex(self):
@@ -955,6 +845,11 @@ class SamCodeCLI:
         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
@@ -1012,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()
@@ -1032,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)
@@ -1048,26 +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")
         
-        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)
@@ -1077,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
@@ -1137,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")
@@ -1186,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)
@@ -1217,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()
@@ -1235,13 +1116,7 @@ class SamCodeCLI:
             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:
-        """Returns True if the user's natural language implies data analysis."""
-        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'
-        ]
+        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):
@@ -1250,39 +1125,36 @@ class SamCodeCLI:
             console.print("[red]Configure AI first with /connect[/red]")
             return
         
-        # NEW: Proactive Code Doctor - Auto-analyze when intent detected
         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)
-            )
+            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
+                    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]")
+                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"
-            for doc in self.session_context: 
-                context_str += f"=== {doc['filename']} ===\n{doc['content']}\n\n"
-        
-        # Append proactive findings to context
-        if proactive_findings:
-            context_str += proactive_findings
+            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 = "\n9. TOKEN ECONOMY RULE: NEVER output actual source code, scripts, or configuration files in your conversational text. Only describe what you are doing (e.g., \"Reading main.py...\", \"Generating the API endpoint...\"). Actual code must ONLY be placed inside the [WRITE_FILE] tool block. This saves tokens and keeps the chat clean."
+        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:
@@ -1296,12 +1168,19 @@ class SamCodeCLI:
     - 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.
 """
 
-        # NEW: Hybrid Data Analyst Rules (Auto-detect + Explicit Mode)
         data_analyst_rules = ""
         is_data_task = self.data_mode or self._detect_data_intent(question)
-        
         if is_data_task:
-            data_analyst_rules = """
+            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.
@@ -1314,7 +1193,7 @@ class SamCodeCLI:
 
         caveman_rules = ""
         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 or absolute minimum words. No explanations. No greetings. Grunt-like brevity."
+        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}
@@ -1330,6 +1209,9 @@ You have access to the following tools to help you complete tasks:
 [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 or execute commands.
@@ -1340,20 +1222,41 @@ CRITICAL RULES:
 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 (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.{token_economy_rule}{frontend_rules}{data_analyst_rules}{caveman_rules}"""
+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})
         
-        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
+                
+                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|SEARCH_SEMANTIC):\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'
@@ -1363,14 +1266,20 @@ 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
@@ -1379,8 +1288,7 @@ CRITICAL RULES:
                     
                     if tool_name == "SEARCH_SEMANTIC":
                         results = self.memory.search(tool_arg)
-                        if not results:
-                            tool_result = "No semantically relevant code found in the codebase."
+                        if not results: tool_result = "No semantically relevant code found in the codebase."
                         else:
                             formatted = []
                             for r in results:
@@ -1393,12 +1301,14 @@ CRITICAL RULES:
                     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):
@@ -1408,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."})
@@ -1428,6 +1367,7 @@ CRITICAL RULES:
             "/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"
@@ -1458,8 +1398,9 @@ CRITICAL RULES:
                 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()  # NEW: Handle data mode toggle
+                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.4 → samcode_cli-1.0.5/samcode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: samcode-cli
-Version: 1.0.4
+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.4 → samcode_cli-1.0.5}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text(encoding="utf-8")
 
 setup(
     name='samcode-cli',
-    version='1.0.4',  # IMPORTANT: Bumped version!
+    version='1.0.5',  # IMPORTANT: Bumped version!
     description='An autonomous AI coding agent that runs in your terminal.',
     long_description=long_description,
     long_description_content_type="text/markdown",