Elizabeth data update 2025-08-24 01:18

elizabeth_memory.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b821f43479f7e991aa42123fd6f4550aab786a073db7520c4d470b04cee25dce
-size 6025216
+oid sha256:515be823d8a4eb4d38ae15eedd971725abbf0ae31dba998fe5af4b21a6b1a196
+size 7716864

manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0",
-  "timestamp": "2025-08-23T17:33:09.802721",
+  "timestamp": "2025-08-24T01:18:11.743713",
   "elizabeth_version": "v0.0.2",
   "data_sources": [
     {

repository/versions/v0_0_2/elizabeth_enhanced.py

@@ -211,6 +211,34 @@ Use your tool belt responsibly to enhance our collaboration."""
                 "inference": self.huggingface_inference,
                 "model_info": self.huggingface_model_info,
                 "list_models": self.huggingface_list_models
+            },
+            "web_and_file_ops": {
+                "web_search": self.web_search,
+                "read_file": self.read_file,
+                "write_file": self.write_file,
+                "list_files": self.list_files,
+                "create_directory": self.create_directory,
+                "file_info": self.get_file_info
+            },
+            "github_ops": {
+                "auto_version": self.auto_version_file,
+                "git_status": self.git_status,
+                "git_commit": self.git_commit,
+                "git_push": self.git_push,
+                "git_pull": self.git_pull
+            },
+            "code_operations": {
+                "generate_code": self.generate_code,
+                "analyze_code": self.analyze_code,
+                "refactor_code": self.refactor_code,
+                "debug_code": self.debug_code,
+                "run_tests": self.run_tests,
+                "optimize_code": self.optimize_code,
+                "document_code": self.document_code
+            },
+            "system_tools": {
+                "list_tools": self.list_available_tools,
+                "tool_info": self.get_tool_info
             }
         }
     
@@ -971,6 +999,959 @@ Use your tool belt responsibly to enhance our collaboration."""
     # build_context_with_memory_and_thinking, chat_with_full_capabilities, store_exchange_with_thinking,
     # display_response, run_interactive would be maintained with enhancements
     
+    # Web and File Operations
+    def web_search(self, query: str, max_results: int = None, provider: str = None) -> Dict[str, Any]:
+        """Perform web search using multiple providers (FireCrawl, Tavily, Serper, DuckDuckGo, Perplexity, Algolia)"""
+        try:
+            provider = provider or os.getenv("SEARCH_PROVIDER", "firecrawl")
+            max_results = max_results or int(os.getenv("SEARCH_MAX_RESULTS", 5))
+            
+            if provider == "firecrawl":
+                return self._firecrawl_search(query, max_results)
+            elif provider == "tavily":
+                return self._tavily_search(query, max_results)
+            elif provider == "serper":
+                return self._serper_search(query, max_results)
+            elif provider == "perplexity":
+                return self._perplexity_search(query, max_results)
+            elif provider == "algolia":
+                return self._algolia_search(query, max_results)
+            else:
+                return self._duckduckgo_search(query, max_results)
+                
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def _firecrawl_search(self, query: str, max_results: int) -> Dict[str, Any]:
+        """Search using FireCrawl API"""
+        api_key = os.getenv("FIRECRAWL_API_KEY")
+        if not api_key:
+            return {"success": False, "error": "FIRECRAWL_API_KEY not configured"}
+        
+        try:
+            import requests
+            
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "url": query,
+                "formats": ["markdown"],
+                "onlyMainContent": True,
+                "limit": max_results
+            }
+            
+            response = requests.post(
+                "https://api.firecrawl.dev/v1/scrape",
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                return {
+                    "success": True,
+                    "query": query,
+                    "results": data.get("data", []),
+                    "provider": "firecrawl"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"FireCrawl API error: {response.status_code}",
+                    "provider": "firecrawl"
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e), "provider": "firecrawl"}
+    
+    def _tavily_search(self, query: str, max_results: int) -> Dict[str, Any]:
+        """Search using Tavily API"""
+        api_key = os.getenv("TAVILY_API_KEY")
+        if not api_key:
+            return {"success": False, "error": "TAVILY_API_KEY not configured"}
+        
+        try:
+            from tavily import TavilyClient
+            
+            tavily = TavilyClient(api_key=api_key)
+            response = tavily.search(query=query, max_results=max_results)
+            
+            return {
+                "success": True,
+                "query": query,
+                "results": response.get("results", []),
+                "provider": "tavily"
+            }
+            
+        except ImportError:
+            return {"success": False, "error": "tavily not installed", "provider": "tavily"}
+        except Exception as e:
+            return {"success": False, "error": str(e), "provider": "tavily"}
+    
+    def _serper_search(self, query: str, max_results: int) -> Dict[str, Any]:
+        """Search using Serper API"""
+        api_key = os.getenv("SERPER_API_KEY")
+        if not api_key:
+            return {"success": False, "error": "SERPER_API_KEY not configured"}
+        
+        try:
+            import requests
+            
+            payload = {
+                "q": query,
+                "num": max_results
+            }
+            
+            headers = {
+                "X-API-KEY": api_key,
+                "Content-Type": "application/json"
+            }
+            
+            response = requests.post(
+                "https://google.serper.dev/search",
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                return {
+                    "success": True,
+                    "query": query,
+                    "results": data.get("organic", []),
+                    "provider": "serper"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Serper API error: {response.status_code}",
+                    "provider": "serper"
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e), "provider": "serper"}
+    
+    def _duckduckgo_search(self, query: str, max_results: int) -> Dict[str, Any]:
+        """Search using DuckDuckGo fallback"""
+        try:
+            from ddgs import DDGS
+            
+            with DDGS() as ddgs:
+                results = []
+                for result in ddgs.text(query, max_results=max_results):
+                    results.append({
+                        "title": result.get("title", ""),
+                        "url": result.get("href", ""),
+                        "snippet": result.get("body", "")
+                    })
+                
+                return {
+                    "success": True,
+                    "query": query,
+                    "results": results,
+                    "result_count": len(results),
+                    "provider": "duckduckgo"
+                }
+                
+        except ImportError:
+            return {"success": False, "error": "ddgs not installed", "provider": "duckduckgo"}
+        except Exception as e:
+            return {"success": False, "error": str(e), "provider": "duckduckgo"}
+    
+    def _perplexity_search(self, query: str, max_results: int) -> Dict[str, Any]:
+        """Search using Perplexity API"""
+        api_key = os.getenv("PERPLEXITY_API_KEY")
+        if not api_key:
+            return {"success": False, "error": "PERPLEXITY_API_KEY not configured", "provider": "perplexity"}
+        
+        try:
+            import requests
+            
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "model": "sonar",
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": "You are a helpful assistant that provides accurate and concise web search results."
+                    },
+                    {
+                        "role": "user", 
+                        "content": query
+                    }
+                ],
+                "max_tokens": 1000,
+                "temperature": 0.1
+            }
+            
+            response = requests.post(
+                "https://api.perplexity.ai/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                content = data['choices'][0]['message']['content']
+                
+                return {
+                    "success": True,
+                    "query": query,
+                    "results": [{"content": content}],
+                    "result_count": 1,
+                    "provider": "perplexity"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Perplexity API error: {response.status_code}",
+                    "provider": "perplexity"
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e), "provider": "perplexity"}
+    
+    def _algolia_search(self, query: str, max_results: int) -> Dict[str, Any]:
+        """Search using Algolia API"""
+        app_id = os.getenv("ALGOLIA_APPLICATION_ID")
+        api_key = os.getenv("ALGOLIA_SEARCH_API_KEY")
+        
+        if not app_id or not api_key:
+            return {"success": False, "error": "Algolia credentials not configured", "provider": "algolia"}
+        
+        try:
+            import requests
+            
+            headers = {
+                "X-Algolia-Application-Id": app_id,
+                "X-Algolia-API-Key": api_key
+            }
+            
+            payload = {
+                "query": query,
+                "hitsPerPage": max_results
+            }
+            
+            response = requests.post(
+                "https://{app_id}-dsn.algolia.net/1/indexes/*/queries".format(app_id=app_id),
+                headers=headers,
+                json={"requests": [payload]},
+                timeout=15
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                hits = data['results'][0]['hits'] if data['results'] else []
+                
+                results = []
+                for hit in hits:
+                    results.append({
+                        "title": hit.get("title", ""),
+                        "url": hit.get("url", ""),
+                        "snippet": hit.get("description", ""),
+                        "objectID": hit.get("objectID", "")
+                    })
+                
+                return {
+                    "success": True,
+                    "query": query,
+                    "results": results,
+                    "result_count": len(results),
+                    "provider": "algolia"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Algolia API error: {response.status_code}",
+                    "provider": "algolia"
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e), "provider": "algolia"}
+    
+    def read_file(self, file_path: str) -> Dict[str, Any]:
+        """Read content from a file"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            return {
+                "success": True,
+                "file_path": file_path,
+                "content": content,
+                "size": len(content),
+                "lines": len(content.split('\n'))
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def write_file(self, file_path: str, content: str, mode: str = "w", backup: bool = True) -> Dict[str, Any]:
+        """Write content to a file with safety checks and versioning"""
+        try:
+            from pathlib import Path
+            
+            path = Path(file_path)
+            
+            # Safety check: if file exists and we're overwriting, create backup
+            if backup and path.exists() and mode == "w":
+                backup_path = f"{file_path}.backup_{int(time.time())}"
+                shutil.copy2(file_path, backup_path)
+                backup_created = True
+            else:
+                backup_created = False
+            
+            # Write the file
+            with open(file_path, mode, encoding='utf-8') as f:
+                f.write(content)
+            
+            # Auto-version to GitHub if configured
+            versioned = False
+            if backup and path.exists() and mode == "w":
+                versioned = self.auto_version_file(file_path)
+            
+            return {
+                "success": True,
+                "file_path": file_path,
+                "action": "created" if mode == "w" else "appended",
+                "size": len(content),
+                "backup_created": backup_created,
+                "versioned": versioned
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def list_files(self, directory: str = ".", pattern: str = "*") -> Dict[str, Any]:
+        """List files in a directory with optional pattern matching"""
+        try:
+            from pathlib import Path
+            import glob
+            
+            path = Path(directory)
+            if not path.exists():
+                return {"success": False, "error": f"Directory not found: {directory}"}
+            
+            files = []
+            for file_path in path.glob(pattern):
+                if file_path.is_file():
+                    files.append({
+                        "name": file_path.name,
+                        "path": str(file_path),
+                        "size": file_path.stat().st_size,
+                        "modified": file_path.stat().st_mtime
+                    })
+            
+            return {
+                "success": True,
+                "directory": directory,
+                "pattern": pattern,
+                "files": files,
+                "file_count": len(files)
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def create_directory(self, directory_path: str) -> Dict[str, Any]:
+        """Create a directory"""
+        try:
+            from pathlib import Path
+            
+            path = Path(directory_path)
+            path.mkdir(parents=True, exist_ok=True)
+            
+            return {
+                "success": True,
+                "directory_path": directory_path,
+                "action": "created" if not path.exists() else "already_exists"
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def get_file_info(self, file_path: str) -> Dict[str, Any]:
+        """Get detailed information about a file"""
+        try:
+            from pathlib import Path
+            import os
+            
+            path = Path(file_path)
+            if not path.exists():
+                return {"success": False, "error": f"File not found: {file_path}"}
+            
+            stat = path.stat()
+            return {
+                "success": True,
+                "file_path": file_path,
+                "name": path.name,
+                "size": stat.st_size,
+                "modified": stat.st_mtime,
+                "created": stat.st_ctime,
+                "is_file": path.is_file(),
+                "is_dir": path.is_dir(),
+                "extension": path.suffix,
+                "absolute_path": str(path.absolute())
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    # GitHub Operations
+    def auto_version_file(self, file_path: str) -> bool:
+        """Automatically version a file to GitHub"""
+        try:
+            from pathlib import Path
+            
+            path = Path(file_path)
+            if not path.exists():
+                return False
+            
+            # Check if we're in a git repository
+            repo_root = self.find_git_root()
+            if not repo_root:
+                return False
+            
+            # Add file to git
+            result = subprocess.run(
+                ["git", "add", str(path.relative_to(repo_root))], 
+                cwd=repo_root, 
+                capture_output=True, 
+                text=True
+            )
+            
+            if result.returncode != 0:
+                return False
+            
+            # Commit with automated message
+            commit_message = f"Auto-version: {path.name} - {datetime.now().isoformat()}"
+            result = subprocess.run(
+                ["git", "commit", "-m", commit_message],
+                cwd=repo_root,
+                capture_output=True,
+                text=True
+            )
+            
+            return result.returncode == 0
+            
+        except Exception:
+            return False
+    
+    def find_git_root(self, path: str = None) -> Optional[str]:
+        """Find the root of the git repository"""
+        try:
+            if path is None:
+                path = os.getcwd()
+            
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                cwd=path,
+                capture_output=True,
+                text=True
+            )
+            
+            if result.returncode == 0:
+                return result.stdout.strip()
+            return None
+            
+        except Exception:
+            return None
+    
+    def git_status(self) -> Dict[str, Any]:
+        """Get git status"""
+        try:
+            repo_root = self.find_git_root()
+            if not repo_root:
+                return {"success": False, "error": "Not in git repository"}
+            
+            result = subprocess.run(
+                ["git", "status", "--porcelain"],
+                cwd=repo_root,
+                capture_output=True,
+                text=True
+            )
+            
+            return {
+                "success": True,
+                "status": result.stdout.strip(),
+                "return_code": result.returncode
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def git_commit(self, message: str) -> Dict[str, Any]:
+        """Commit changes to git"""
+        try:
+            repo_root = self.find_git_root()
+            if not repo_root:
+                return {"success": False, "error": "Not in git repository"}
+            
+            result = subprocess.run(
+                ["git", "commit", "-a", "-m", message],
+                cwd=repo_root,
+                capture_output=True,
+                text=True
+            )
+            
+            return {
+                "success": result.returncode == 0,
+                "output": result.stdout.strip(),
+                "error": result.stderr.strip()
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def git_push(self) -> Dict[str, Any]:
+        """Push to git remote"""
+        try:
+            repo_root = self.find_git_root()
+            if not repo_root:
+                return {"success": False, "error": "Not in git repository"}
+            
+            result = subprocess.run(
+                ["git", "push"],
+                cwd=repo_root,
+                capture_output=True,
+                text=True
+            )
+            
+            return {
+                "success": result.returncode == 0,
+                "output": result.stdout.strip(),
+                "error": result.stderr.strip()
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def git_pull(self) -> Dict[str, Any]:
+        """Pull from git remote"""
+        try:
+            repo_root = self.find_git_root()
+            if not repo_root:
+                return {"success": False, "error": "Not in git repository"}
+            
+            result = subprocess.run(
+                ["git", "pull"],
+                cwd=repo_root,
+                capture_output=True,
+                text=True
+            )
+            
+            return {
+                "success": result.returncode == 0,
+                "output": result.stdout.strip(),
+                "error": result.stderr.strip()
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    # System Tools
+    def list_available_tools(self, category: str = None) -> Dict[str, Any]:
+        """List all available tools with their command names"""
+        try:
+            tools_list = {}
+            
+            for category_name, tools in self.tool_belt.items():
+                if category and category_name != category:
+                    continue
+                
+                tools_list[category_name] = {}
+                for tool_name, tool_method in tools.items():
+                    # Get method documentation
+                    docstring = tool_method.__doc__ or "No description available"
+                    # Clean up docstring
+                    description = docstring.split('\n')[0].strip() if docstring else "No description"
+                    
+                    tools_list[category_name][tool_name] = {
+                        "description": description,
+                        "method": tool_method.__name__
+                    }
+            
+            return {
+                "success": True,
+                "tools": tools_list,
+                "total_categories": len(tools_list),
+                "total_tools": sum(len(tools) for tools in tools_list.values())
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def get_tool_info(self, tool_name: str) -> Dict[str, Any]:
+        """Get detailed information about a specific tool"""
+        try:
+            for category_name, tools in self.tool_belt.items():
+                if tool_name in tools:
+                    tool_method = tools[tool_name]
+                    docstring = tool_method.__doc__ or ""
+                    
+                    # Parse signature if possible
+                    import inspect
+                    try:
+                        sig = inspect.signature(tool_method)
+                        parameters = {}
+                        for param_name, param in sig.parameters.items():
+                            parameters[param_name] = {
+                                "type": str(param.annotation) if param.annotation != param.empty else "any",
+                                "default": param.default if param.default != param.empty else "required",
+                                "kind": str(param.kind)
+                            }
+                    except:
+                        parameters = {}
+                    
+                    return {
+                        "success": True,
+                        "tool_name": tool_name,
+                        "category": category_name,
+                        "description": docstring.split('\n')[0].strip() if docstring else "No description",
+                        "full_docstring": docstring,
+                        "parameters": parameters,
+                        "method": tool_method.__name__
+                    }
+            
+            return {"success": False, "error": f"Tool not found: {tool_name}"}
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    # Session Management Methods
+    def list_sessions(self) -> List[Dict]:
+        """List all available sessions"""
+        try:
+            conn = sqlite3.connect(self.sqlite_db)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT session_id, COUNT(*) as message_count, MAX(timestamp) as last_activity
+                FROM elizabeth_conversations
+                GROUP BY session_id
+                ORDER BY last_activity DESC
+            ''')
+            
+            sessions = []
+            for session_id, message_count, last_activity in cursor.fetchall():
+                sessions.append({
+                    "session_id": session_id,
+                    "message_count": message_count,
+                    "last_activity": last_activity
+                })
+            
+            conn.close()
+            return sessions
+            
+        except Exception as e:
+            return []
+
+    def load_session(self, session_id: str) -> Dict[str, Any]:
+        """Load a specific session"""
+        try:
+            conn = sqlite3.connect(self.sqlite_db)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT role, content, thinking, metadata 
+                FROM elizabeth_conversations 
+                WHERE session_id = ?
+                ORDER BY timestamp ASC
+            ''', (session_id,))
+            
+            self.conversation_history = []
+            for role, content, thinking, metadata in cursor.fetchall():
+                self.conversation_history.append({
+                    "role": role,
+                    "content": content,
+                    "thinking": thinking,
+                    "metadata": json.loads(metadata) if metadata else {}
+                })
+            
+            self.session_id = session_id
+            conn.close()
+            
+            return {
+                "success": True,
+                "session_id": session_id,
+                "message_count": len(self.conversation_history),
+                "loaded_messages": len(self.conversation_history)
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def save_session(self, session_name: str = None) -> Dict[str, Any]:
+        """Save current session with optional name"""
+        try:
+            if session_name:
+                # Create a named session by updating all messages
+                conn = sqlite3.connect(self.sqlite_db)
+                cursor = conn.cursor()
+                
+                cursor.execute('''
+                    UPDATE elizabeth_conversations 
+                    SET session_id = ?
+                    WHERE session_id = ?
+                ''', (session_name, self.session_id))
+                
+                conn.commit()
+                conn.close()
+                
+                self.session_id = session_name
+                
+                return {
+                    "success": True,
+                    "session_id": session_name,
+                    "message_count": len(self.conversation_history),
+                    "action": "renamed"
+                }
+            else:
+                # Just return current session info
+                return {
+                    "success": True,
+                    "session_id": self.session_id,
+                    "message_count": len(self.conversation_history),
+                    "action": "current"
+                }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def get_session_info(self) -> Dict[str, Any]:
+        """Get information about current session"""
+        try:
+            conn = sqlite3.connect(self.sqlite_db)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT COUNT(*) as message_count, 
+                       MIN(timestamp) as start_time,
+                       MAX(timestamp) as last_activity
+                FROM elizabeth_conversations
+                WHERE session_id = ?
+            ''', (self.session_id,))
+            
+            result = cursor.fetchone()
+            conn.close()
+            
+            if result:
+                message_count, start_time, last_activity = result
+                return {
+                    "session_id": self.session_id,
+                    "message_count": message_count,
+                    "start_time": start_time,
+                    "last_activity": last_activity,
+                    "current_memory_load": len(self.conversation_history),
+                    "version": self.version
+                }
+            else:
+                return {"error": "Session not found"}
+            
+        except Exception as e:
+            return {"error": str(e)}
+    
+    # Code Operations Tools
+    def generate_code(self, specification: str, language: str = "python", context: str = None) -> Dict[str, Any]:
+        """Generate code based on specification and programming language"""
+        try:
+            # Use Elizabeth's own AI capabilities to generate code
+            prompt = f"Generate {language} code for: {specification}"
+            if context:
+                prompt += f"\nContext: {context}"
+            
+            # Use the chat capability to generate code
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            # Extract code from response (assuming code is in markdown code blocks)
+            import re
+            code_blocks = re.findall(r'```(?:\w+)?\n(.*?)\n```', response, re.DOTALL)
+            
+            if code_blocks:
+                generated_code = code_blocks[0].strip()
+                return {
+                    "success": True,
+                    "language": language,
+                    "code": generated_code,
+                    "specification": specification,
+                    "thinking_process": thinking_blocks
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "No code block found in response",
+                    "response": response
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def analyze_code(self, code: str, language: str = "python") -> Dict[str, Any]:
+        """Analyze code for quality, security, and performance issues"""
+        try:
+            prompt = f"Analyze this {language} code for quality, security, and performance issues:\n\n{code}"
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            return {
+                "success": True,
+                "analysis": response,
+                "language": language,
+                "thinking_process": thinking_blocks
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def refactor_code(self, code: str, language: str = "python", goals: str = None) -> Dict[str, Any]:
+        """Refactor code to improve quality, performance, or maintainability"""
+        try:
+            prompt = f"Refactor this {language} code"
+            if goals:
+                prompt += f" with goals: {goals}"
+            prompt += f":\n\n{code}"
+            
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            # Extract refactored code
+            import re
+            code_blocks = re.findall(r'```(?:\w+)?\n(.*?)\n```', response, re.DOTALL)
+            
+            if code_blocks:
+                refactored_code = code_blocks[0].strip()
+                return {
+                    "success": True,
+                    "original_code": code,
+                    "refactored_code": refactored_code,
+                    "language": language,
+                    "explanation": response,
+                    "thinking_process": thinking_blocks
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "No refactored code block found",
+                    "analysis": response
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def debug_code(self, code: str, error: str = None, language: str = "python") -> Dict[str, Any]:
+        """Debug code and identify/fix issues"""
+        try:
+            prompt = f"Debug this {language} code"
+            if error:
+                prompt += f" that produces error: {error}"
+            prompt += f":\n\n{code}"
+            
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            # Extract fixed code
+            import re
+            code_blocks = re.findall(r'```(?:\w+)?\n(.*?)\n```', response, re.DOTALL)
+            
+            if code_blocks:
+                debugged_code = code_blocks[0].strip()
+                return {
+                    "success": True,
+                    "original_code": code,
+                    "debugged_code": debugged_code,
+                    "language": language,
+                    "explanation": response,
+                    "thinking_process": thinking_blocks
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "No debugged code block found",
+                    "analysis": response
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def run_tests(self, code: str, test_code: str = None, language: str = "python") -> Dict[str, Any]:
+        """Run tests on code and report results"""
+        try:
+            if test_code:
+                prompt = f"Run these tests on the {language} code and report results. Code:\n\n{code}\n\nTests:\n\n{test_code}"
+            else:
+                prompt = f"Create and run tests for this {language} code and report results:\n\n{code}"
+            
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            return {
+                "success": True,
+                "code": code,
+                "test_results": response,
+                "language": language,
+                "thinking_process": thinking_blocks
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def optimize_code(self, code: str, language: str = "python", metric: str = "performance") -> Dict[str, Any]:
+        """Optimize code for performance, memory usage, or other metrics"""
+        try:
+            prompt = f"Optimize this {language} code for {metric}:\n\n{code}"
+            
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            # Extract optimized code
+            import re
+            code_blocks = re.findall(r'```(?:\w+)?\n(.*?)\n```', response, re.DOTALL)
+            
+            if code_blocks:
+                optimized_code = code_blocks[0].strip()
+                return {
+                    "success": True,
+                    "original_code": code,
+                    "optimized_code": optimized_code,
+                    "language": language,
+                    "metric": metric,
+                    "explanation": response,
+                    "thinking_process": thinking_blocks
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "No optimized code block found",
+                    "analysis": response
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def document_code(self, code: str, language: str = "python", style: str = "google") -> Dict[str, Any]:
+        """Generate documentation for code"""
+        try:
+            prompt = f"Generate {style}-style documentation for this {language} code:\n\n{code}"
+            
+            thinking_blocks, response = self.chat_with_full_capabilities(prompt)
+            
+            return {
+                "success": True,
+                "code": code,
+                "documentation": response,
+                "language": language,
+                "style": style,
+                "thinking_process": thinking_blocks
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
     def load_full_history(self) -> List[Dict]:
         """Load Elizabeth's complete conversation history with thinking"""
         conn = sqlite3.connect(self.sqlite_db)
@@ -1153,20 +2134,26 @@ Think step by step, then provide your final response after </think>
             except Exception as e:
                 console.print(f"[red]Error: {e}[/red]")
     
-    def run_enhanced_interactive(self):
+    def run_enhanced_interactive(self, session_id: str = None):
         """Run enhanced interactive session with full tool belt"""
         
+        # Load specific session if provided
+        if session_id:
+            self.load_session(session_id)
+        
         console.print(Panel.fit(
             f"[bold cyan]Elizabeth Enhanced {self.version} - Full Autonomy[/bold cyan]\n"
             "[dim]Qwen3-8B with Thinking Mode, Memory & Tool Belt[/dim]\n"
-            "[dim yellow]Commands: /quit, /clear, /thinking on/off, /db query <sql>, /version snapshot, /system status[/dim yellow]",
+            "[dim yellow]Commands: /quit, /clear, /thinking on/off, /db query <sql>, /version snapshot, /system status[/dim yellow]\n"
+            "[dim yellow]/session list, /session load <id>, /session save <name>, /session info[/dim yellow]",
             border_style="cyan"
         ))
         
-        # Show system status
+        # Show system status and session info
         status = self.get_system_status()
         console.print(f"[dim green]📊 System Version: {status['version']}[/dim green]")
         console.print(f"[dim green]📚 Loaded {len(self.conversation_history)} memories[/dim green]")
+        console.print(f"[dim green]💾 Current Session: {self.session_id}[/dim green]")
         
         # Enhanced greeting with tool awareness
         console.print("\n[bold magenta]Elizabeth:[/bold magenta]")
@@ -1213,6 +2200,41 @@ Think step by step, then provide your final response after </think>
                     for version in versions:
                         console.print(f"  [dim]• {version['version_id']}: {version['description']}[/dim]")
                     continue
+                    
+                # Session management commands
+                if user_input.lower() == '/session list':
+                    sessions = self.list_sessions()
+                    console.print("\n[dim cyan]Available Sessions:[/dim cyan]")
+                    for session in sessions:
+                        console.print(f"  [dim]• {session['session_id']}: {session['message_count']} messages, {session['last_activity']}[/dim]")
+                    continue
+                    
+                if user_input.startswith('/session load'):
+                    session_id = user_input.replace('/session load', '').strip()
+                    if session_id:
+                        result = self.load_session(session_id)
+                        if result["success"]:
+                            console.print(f"\n[green]✅ Loaded session: {session_id}[/green]")
+                            console.print(f"[dim]Loaded {len(self.conversation_history)} messages[/dim]")
+                        else:
+                            console.print(f"\n[red]❌ Error loading session: {result['error']}[/red]")
+                    continue
+                    
+                if user_input.startswith('/session save'):
+                    session_name = user_input.replace('/session save', '').strip()
+                    if session_name:
+                        result = self.save_session(session_name)
+                        if result["success"]:
+                            console.print(f"\n[green]✅ Session saved as: {session_name}[/green]")
+                        else:
+                            console.print(f"\n[red]❌ Error saving session: {result['error']}[/red]")
+                    continue
+                    
+                if user_input.lower() == '/session info':
+                    session_info = self.get_session_info()
+                    console.print("\n[dim cyan]Current Session Info:[/dim cyan]")
+                    console.print(json.dumps(session_info, indent=2))
+                    continue
                 
                 # Process with enhanced capabilities
                 console.print("[dim]Elizabeth is thinking with full tool access...[/dim]")
@@ -1238,6 +2260,40 @@ def main():
         elif sys.argv[1] == "--status":
             status = elizabeth.get_system_status()
             console.print(json.dumps(status, indent=2))
+        elif sys.argv[1] == "-c" or sys.argv[1] == "--continue":
+            # Session continuation mode
+            if len(sys.argv) > 2:
+                session_id = sys.argv[2]
+                console.print(f"[dim]Continuing session: {session_id}[/dim]")
+                elizabeth.run_enhanced_interactive(session_id)
+            else:
+                # List available sessions and let user choose
+                sessions = elizabeth.list_sessions()
+                if sessions:
+                    console.print("[dim cyan]Available Sessions:[/dim cyan]")
+                    for i, session in enumerate(sessions[:5]):
+                        console.print(f"  [dim]{i+1}. {session['session_id']}: {session['message_count']} messages[/dim]")
+                    
+                    try:
+                        choice = console.input("\n[dim]Enter session number to continue (or press Enter for new session): [/dim]").strip()
+                        if choice and choice.isdigit():
+                            session_index = int(choice) - 1
+                            if 0 <= session_index < len(sessions):
+                                session_id = sessions[session_index]['session_id']
+                                console.print(f"[dim]Continuing session: {session_id}[/dim]")
+                                elizabeth.run_enhanced_interactive(session_id)
+                            else:
+                                console.print("[yellow]Invalid session number, starting new session[/yellow]")
+                                elizabeth.run_enhanced_interactive()
+                        else:
+                            console.print("[dim]Starting new session[/dim]")
+                            elizabeth.run_enhanced_interactive()
+                    except:
+                        console.print("[yellow]Invalid input, starting new session[/yellow]")
+                        elizabeth.run_enhanced_interactive()
+                else:
+                    console.print("[yellow]No sessions found, starting new session[/yellow]")
+                    elizabeth.run_enhanced_interactive()
         else:
             # Single message mode
             message = " ".join(sys.argv[1:])