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

samcode_cli-1.0.4/MANIFEST.in

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

{samcode_cli-1.0.2 → samcode_cli-1.0.4}/PKG-INFO

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

{samcode_cli-1.0.2 → samcode_cli-1.0.4}/samcode.py

@@ -2,7 +2,7 @@
 """
 ╔══════════════════════════════════════════════════════════════════════════════╗
 ║                          S A M C O D E   C L I                              ║
-║                   Autonomous Coding Agent v5.4                              ║
+║                   Autonomous Coding Agent v6.2 (RAG + Doctor + Data BI)     ║
 ║              Similar to Claude Code & GitHub Copilot Workspace              ║
 ╚══════════════════════════════════════════════════════════════════════════════╝
 """
@@ -21,7 +21,7 @@ from dataclasses import dataclass
 from enum import Enum
 
 # Rich UI Components
-from rich.console import Console
+from rich.console import Console, Group
 from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
@@ -47,6 +47,9 @@ 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:
@@ -55,16 +58,6 @@ except ImportError:
     subprocess.run([sys.executable, "-m", "pip", "install", "requests", "-q"], capture_output=True)
     import requests
 
-# Document Processing & Web Parsing Libraries Auto-Install
-LIBS_TO_INSTALL = {
-    'pdfplumber': 'pdfplumber', 'docx': 'python-docx', 'openpyxl': 'openpyxl',
-    'pptx': 'python-pptx', 'PIL': 'Pillow', 'bs4': 'beautifulsoup4'
-}
-for module, package in LIBS_TO_INSTALL.items():
-    try:
-        __import__(module)
-    except ImportError:
-        subprocess.run([sys.executable, "-m", "pip", "install", package, "-q"], capture_output=True)
 
 console = Console()
 
@@ -74,6 +67,31 @@ menu_style = Style.from_dict({
     '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'
+}
+
+for module, package in LIBS_TO_INSTALL.items():
+    try:
+        __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)
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -102,6 +120,222 @@ def _(event):
     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
+        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')
+            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
+
+    def index_workspace(self, file_manager: 'FileSystemManager'):
+        """Scan and embed all code files in the workspace."""
+        if self._is_indexed:
+            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:
+            ext = Path(f).suffix.lower()
+            if ext in code_extensions:
+                content = file_manager.read_file(f)
+                if content and len(content) < 10000:  # Skip huge files
+                    docs.append(f"File: {f}\nContent:\n{content}")
+                    ids.append(f.replace(os.sep, "_"))
+                    metadatas.append({"file": f, "ext": ext})
+        
+        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]")
+        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."""
+        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])
+        ]
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 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'
+    ]
+    
+    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)
+    
+    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:
+            results = memory.search(user_prompt, n_results=5)
+            if results:
+                return [r['file'] for r in results]
+        
+        # Fallback: extract filenames mentioned in prompt
+        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
+    
+    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
+                
+            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]:  # Limit per file
+                                row = issue.get('location', {}).get('row', '?')
+                                code = issue.get('code', '')
+                                msg = issue.get('message', '')
+                                summary += f"  • Line {row}: [{code}] {msg}\n"
+                            findings[filepath] = summary
+                            
+            except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+                # Silently skip if tool isn't installed or fails
+                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)}"
+
+        # 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()}"
+            )
+            return df, meta
+            
+        except Exception as e:
+            return None, f"[READ_ERROR] {str(e)}"
+
+
 class DocumentReader:
     @staticmethod
     def extract_text(filepath: str) -> str:
@@ -522,11 +756,22 @@ class SamCodeCLI:
         self.api_key = ""
         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.session_context = [] 
         self.file_manager = FileSystemManager(self.workspace_dir)
         self.command_runner = CommandRunner(self.workspace_dir)
         self.git_manager = GitManager(self.workspace_dir, console)
-        self.command_completer = WordCompleter(['/connect', '/models', '/upload', '/clear-uploads', '/caveman', '/clear', '/exit', '/help', '/aboutme', '/searchweb', '/git'], sentence=True)
+        
+        # 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.prompt_text = FormattedText([('ansicyan bold', '❯ ')])
         self.load_configuration()
 
@@ -541,11 +786,19 @@ 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 get_client(self) -> Optional[AIModelClient]:
         provider_config = self.provider_registry.get_provider(self.active_provider)
@@ -555,18 +808,31 @@ class SamCodeCLI:
 
     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)))
+        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 ""
+            
+        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)))
         console.print("[dim]Type your request naturally, or use /help for commands.[/dim]\n")
 
     def cmd_connect(self):
@@ -633,6 +899,62 @@ 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()
+
+    # 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 += "[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"])
+            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)
+        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_upload(self, filepath: str = ""):
         if not filepath: filepath = Prompt.ask("[cyan]Enter file path to upload[/cyan]").strip()
         if not filepath: return
@@ -726,10 +1048,27 @@ 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")
+
         try:
             user_check = subprocess.run(["git", "config", "user.name"], cwd=self.workspace_dir, capture_output=True, text=True, timeout=5)
             if not user_check.stdout.strip():
@@ -895,18 +1234,88 @@ 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:
+        """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'
+        ]
+        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
+        
+        # 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)
+            )
+            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"
-            for doc in self.session_context: context_str += f"=== {doc['filename']} ===\n{doc['content']}\n\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
+        
+        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."
+        
+        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.
+"""
+
+        # 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 = """
+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 or absolute minimum words. No explanations. No greetings. Grunt-like brevity."
+        
         system_msg = f"""You are SamCode CLI, an expert autonomous AI coding agent.
 You are currently working in the directory: {self.workspace_dir}
 
@@ -920,16 +1329,19 @@ 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>]
 
 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}"""
+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}"""
+        
         messages = [{"role": "system", "content": system_msg}, {"role": "user", "content": question}]
         max_iterations = 20
         console.print(f"\n[bold cyan]🤖 Agent Activated[/bold cyan]")
@@ -940,7 +1352,7 @@ CRITICAL RULES:
                 response = client.chat(messages, stream=True)
                 if not response or response.startswith("Error"): console.print(f"\n[red]{response}[/red]"); break
                 write_match = re.search(r'\[WRITE_FILE:\s*(.*?)\](.*?)\[END_WRITE_FILE\]', response, re.DOTALL)
-                single_match = re.search(r'\[(READ_FILE|RUN_TERMINAL|SEARCH_CODE):\s*(.*?)\]', response)
+                single_match = re.search(r'\[(READ_FILE|RUN_TERMINAL|SEARCH_CODE|SEARCH_SEMANTIC):\s*(.*?)\]', response)
                 tool_executed = False
                 if write_match:
                     path = write_match.group(1).strip(); content = write_match.group(2).strip()
@@ -964,7 +1376,21 @@ CRITICAL RULES:
                     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
@@ -991,7 +1417,21 @@ 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",
+            "/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")
 
@@ -1003,7 +1443,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, 
@@ -1018,6 +1457,9 @@ 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()  # NEW: Handle data mode toggle
+                elif user_input.lower() in ["/reindex"]: self.cmd_reindex()
                 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.2 → samcode_cli-1.0.4}/samcode_cli.egg-info/PKG-INFO

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

{samcode_cli-1.0.2 → samcode_cli-1.0.4}/samcode_cli.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+MANIFEST.in
 README.md
 samcode.py
 setup.py

{samcode_cli-1.0.2 → samcode_cli-1.0.4}/setup.py

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