praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/features/audit_cli.py

@@ -0,0 +1,270 @@
+"""
+Security Audit CLI for PraisonAI.
+
+Provides security scanning and audit capabilities.
+"""
+
+from __future__ import annotations
+
+import os
+import logging
+from typing import Dict, Any, List
+
+logger = logging.getLogger(__name__)
+
+
+class SecurityAudit:
+    """Security audit scanner for PraisonAI projects."""
+    
+    def __init__(self):
+        self.findings: List[Dict[str, Any]] = []
+    
+    def scan(self, path: str = ".") -> Dict[str, Any]:
+        """Scan a project for security issues.
+        
+        Args:
+            path: Path to scan
+            
+        Returns:
+            Audit results
+        """
+        self.findings = []
+        
+        self._check_env_files(path)
+        self._check_api_keys_in_code(path)
+        self._check_yaml_configs(path)
+        self._check_dependencies(path)
+        self._check_permissions(path)
+        
+        critical = sum(1 for f in self.findings if f["severity"] == "critical")
+        high = sum(1 for f in self.findings if f["severity"] == "high")
+        medium = sum(1 for f in self.findings if f["severity"] == "medium")
+        low = sum(1 for f in self.findings if f["severity"] == "low")
+        
+        return {
+            "path": path,
+            "findings": self.findings,
+            "summary": {
+                "total": len(self.findings),
+                "critical": critical,
+                "high": high,
+                "medium": medium,
+                "low": low,
+            },
+            "passed": critical == 0 and high == 0,
+        }
+    
+    def _check_env_files(self, path: str) -> None:
+        """Check for exposed .env files."""
+        env_files = []
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if not d.startswith(".git")]
+            for f in files:
+                if f == ".env" or f.endswith(".env"):
+                    env_files.append(os.path.join(root, f))
+        
+        for env_file in env_files:
+            gitignore_path = os.path.join(os.path.dirname(env_file), ".gitignore")
+            if os.path.exists(gitignore_path):
+                with open(gitignore_path, "r") as f:
+                    gitignore = f.read()
+                if ".env" not in gitignore:
+                    self.findings.append({
+                        "type": "exposed_env",
+                        "severity": "critical",
+                        "file": env_file,
+                        "message": ".env file not in .gitignore - secrets may be exposed",
+                        "fix": "Add '.env' to .gitignore",
+                    })
+            else:
+                self.findings.append({
+                    "type": "missing_gitignore",
+                    "severity": "high",
+                    "file": env_file,
+                    "message": "No .gitignore found - .env file may be committed",
+                    "fix": "Create .gitignore with '.env' entry",
+                })
+    
+    def _check_api_keys_in_code(self, path: str) -> None:
+        """Check for hardcoded API keys in code."""
+        import re
+        
+        patterns = [
+            (r'sk-[a-zA-Z0-9]{48}', "OpenAI API key"),
+            (r'sk-ant-[a-zA-Z0-9-]{95}', "Anthropic API key"),
+            (r'AIza[a-zA-Z0-9_-]{35}', "Google API key"),
+            (r'xoxb-[0-9]+-[0-9]+-[a-zA-Z0-9]+', "Slack bot token"),
+            (r'xapp-[0-9]+-[a-zA-Z0-9]+', "Slack app token"),
+        ]
+        
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d != "__pycache__"]
+            for f in files:
+                if f.endswith((".py", ".yaml", ".yml", ".json", ".js", ".ts")):
+                    file_path = os.path.join(root, f)
+                    try:
+                        with open(file_path, "r", encoding="utf-8", errors="ignore") as fp:
+                            content = fp.read()
+                        
+                        for pattern, key_type in patterns:
+                            if re.search(pattern, content):
+                                self.findings.append({
+                                    "type": "hardcoded_key",
+                                    "severity": "critical",
+                                    "file": file_path,
+                                    "message": f"Possible {key_type} found in code",
+                                    "fix": "Move API key to environment variable",
+                                })
+                    except Exception:
+                        pass
+    
+    def _check_yaml_configs(self, path: str) -> None:
+        """Check YAML configurations for security issues."""
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if not d.startswith(".")]
+            for f in files:
+                if f.endswith((".yaml", ".yml")):
+                    file_path = os.path.join(root, f)
+                    try:
+                        import yaml
+                        with open(file_path, "r") as fp:
+                            config = yaml.safe_load(fp)
+                        
+                        if config and isinstance(config, dict):
+                            if "api_key" in str(config).lower():
+                                self.findings.append({
+                                    "type": "key_in_config",
+                                    "severity": "high",
+                                    "file": file_path,
+                                    "message": "API key reference found in YAML config",
+                                    "fix": "Use environment variables instead",
+                                })
+                    except Exception:
+                        pass
+    
+    def _check_dependencies(self, path: str) -> None:
+        """Check for known vulnerable dependencies."""
+        requirements_files = ["requirements.txt", "pyproject.toml"]
+        
+        for req_file in requirements_files:
+            req_path = os.path.join(path, req_file)
+            if os.path.exists(req_path):
+                self.findings.append({
+                    "type": "dependency_check",
+                    "severity": "low",
+                    "file": req_path,
+                    "message": "Run 'pip-audit' to check for vulnerable dependencies",
+                    "fix": "pip install pip-audit && pip-audit",
+                })
+                break
+    
+    def _check_permissions(self, path: str) -> None:
+        """Check file permissions."""
+        sensitive_files = [".env", "credentials.json", "service-account.json"]
+        
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if not d.startswith(".git")]
+            for f in files:
+                if f in sensitive_files:
+                    file_path = os.path.join(root, f)
+                    try:
+                        mode = os.stat(file_path).st_mode
+                        if mode & 0o077:
+                            self.findings.append({
+                                "type": "file_permissions",
+                                "severity": "medium",
+                                "file": file_path,
+                                "message": "Sensitive file has overly permissive permissions",
+                                "fix": f"chmod 600 {file_path}",
+                            })
+                    except Exception:
+                        pass
+
+
+def handle_audit_command(args) -> None:
+    """Handle audit CLI command."""
+    try:
+        from rich.console import Console
+        from rich.table import Table
+        from rich.panel import Panel
+    except ImportError:
+        print("Error: Rich library required for audit display")
+        return
+    
+    console = Console()
+    audit = SecurityAudit()
+    
+    path = getattr(args, "path", ".")
+    results = audit.scan(path)
+    
+    console.print(Panel.fit(
+        f"[bold]Security Audit Results[/bold]\n"
+        f"Path: {results['path']}",
+        title="PraisonAI Security Audit",
+    ))
+    console.print()
+    
+    summary = results["summary"]
+    if summary["total"] == 0:
+        console.print("[green]✓ No security issues found![/green]")
+    else:
+        table = Table(title="Summary")
+        table.add_column("Severity", style="bold")
+        table.add_column("Count", justify="right")
+        
+        if summary["critical"] > 0:
+            table.add_row("[red]Critical[/red]", str(summary["critical"]))
+        if summary["high"] > 0:
+            table.add_row("[orange1]High[/orange1]", str(summary["high"]))
+        if summary["medium"] > 0:
+            table.add_row("[yellow]Medium[/yellow]", str(summary["medium"]))
+        if summary["low"] > 0:
+            table.add_row("[blue]Low[/blue]", str(summary["low"]))
+        
+        console.print(table)
+        console.print()
+        
+        findings_table = Table(title="Findings")
+        findings_table.add_column("Severity")
+        findings_table.add_column("Type")
+        findings_table.add_column("File")
+        findings_table.add_column("Message")
+        
+        severity_colors = {
+            "critical": "red",
+            "high": "orange1",
+            "medium": "yellow",
+            "low": "blue",
+        }
+        
+        for finding in results["findings"]:
+            color = severity_colors.get(finding["severity"], "white")
+            findings_table.add_row(
+                f"[{color}]{finding['severity'].upper()}[/{color}]",
+                finding["type"],
+                finding["file"],
+                finding["message"],
+            )
+        
+        console.print(findings_table)
+        console.print()
+        
+        if not results["passed"]:
+            console.print("[red]✗ Audit failed - critical/high issues found[/red]")
+        else:
+            console.print("[yellow]⚠ Audit passed with warnings[/yellow]")
+
+
+def add_audit_parser(subparsers) -> None:
+    """Add audit subparser to CLI."""
+    audit_parser = subparsers.add_parser(
+        "audit",
+        help="Run security audit on project",
+    )
+    audit_parser.add_argument(
+        "path",
+        nargs="?",
+        default=".",
+        help="Path to audit (default: current directory)",
+    )
+    audit_parser.set_defaults(func=handle_audit_command)

praisonai_code/cli/features/auto_memory.py

@@ -0,0 +1,182 @@
+"""
+Auto Memory Handler for CLI.
+
+Provides automatic memory extraction and storage.
+Usage: praisonai "Learn about user preferences" --auto-memory
+"""
+
+from typing import Any, Dict, Tuple
+from .base import FlagHandler
+
+
+class AutoMemoryHandler(FlagHandler):
+    """
+    Handler for --auto-memory flag.
+    
+    Automatically extracts and stores important information from conversations.
+    
+    Example:
+        praisonai "Learn about user preferences" --auto-memory
+        praisonai "Remember this context" --auto-memory --user-id myuser
+    """
+    
+    @property
+    def feature_name(self) -> str:
+        return "auto_memory"
+    
+    @property
+    def flag_name(self) -> str:
+        return "auto-memory"
+    
+    @property
+    def flag_help(self) -> str:
+        return "Enable automatic memory extraction and storage"
+    
+    def check_dependencies(self) -> Tuple[bool, str]:
+        """Check if AutoMemory is available."""
+        try:
+            import importlib.util
+            if importlib.util.find_spec("praisonaiagents") is not None:
+                return True, ""
+            return False, "praisonaiagents not installed"
+        except ImportError:
+            return False, "praisonaiagents not installed. Install with: pip install praisonaiagents"
+    
+    def _get_auto_memory(self, user_id: str = None):
+        """Get AutoMemory instance lazily."""
+        try:
+            from praisonaiagents.memory import AutoMemory, FileMemory
+            # AutoMemory requires a FileMemory instance
+            memory = FileMemory(user_id=user_id or "default")
+            return AutoMemory(memory=memory)
+        except ImportError:
+            self.print_status(
+                "AutoMemory requires praisonaiagents. Install with: pip install praisonaiagents",
+                "error"
+            )
+            return None
+    
+    def apply_to_agent_config(self, config: Dict[str, Any], flag_value: Any) -> Dict[str, Any]:
+        """
+        Apply auto memory configuration.
+        
+        Args:
+            config: Agent configuration dictionary
+            flag_value: Boolean or dict with user_id
+            
+        Returns:
+            Modified configuration
+        """
+        if flag_value:
+            config['auto_memory'] = True
+            if isinstance(flag_value, dict):
+                config['auto_memory_user_id'] = flag_value.get('user_id', 'default')
+        return config
+    
+    def extract_memories(self, text: str, user_id: str = None, user_message: str = None) -> list:
+        """
+        Extract and store memories from text.
+        
+        Args:
+            text: Assistant response text to extract memories from
+            user_id: User ID for memory isolation
+            user_message: Original user message (for context)
+            
+        Returns:
+            List of extracted memories
+        """
+        auto_memory = self._get_auto_memory(user_id)
+        if not auto_memory:
+            return []
+        
+        try:
+            # Use process_interaction which extracts AND stores memories
+            memories = auto_memory.process_interaction(
+                user_message=user_message or text,
+                assistant_response=text if user_message else None,
+                store=True  # Store the memories
+            )
+            if memories:
+                self.print_status(f"🧠 Extracted and stored {len(memories)} memories", "success")
+            return memories
+        except Exception as e:
+            self.log(f"Memory extraction failed: {e}", "error")
+        
+        return []
+    
+    def store_memory(self, content: str, user_id: str = None, importance: float = 0.5) -> bool:
+        """
+        Store a memory.
+        
+        Args:
+            content: Memory content
+            user_id: User ID for memory isolation
+            importance: Importance score (0-1)
+            
+        Returns:
+            True if successful
+        """
+        auto_memory = self._get_auto_memory(user_id)
+        if not auto_memory:
+            return False
+        
+        try:
+            if hasattr(auto_memory, 'store'):
+                auto_memory.store(content, importance=importance)
+            elif hasattr(auto_memory, 'add'):
+                auto_memory.add(content, importance=importance)
+            
+            self.print_status("✅ Memory stored", "success")
+            return True
+        except Exception as e:
+            self.log(f"Memory storage failed: {e}", "error")
+            return False
+    
+    def post_process_result(self, result: Any, flag_value: Any, user_message: str = None) -> Any:
+        """
+        Post-process result to extract and store memories.
+        
+        Args:
+            result: Agent output
+            flag_value: Boolean or dict with configuration
+            user_message: Original user message for context
+            
+        Returns:
+            Original result (memories are stored)
+        """
+        if not flag_value:
+            return result
+        
+        user_id = None
+        if isinstance(flag_value, dict):
+            user_id = flag_value.get('user_id')
+            user_message = flag_value.get('user_message', user_message)
+        
+        # Extract and store memories from result
+        text = str(result)
+        memories = self.extract_memories(text, user_id, user_message=user_message)
+        
+        if memories:
+            self.print_status("\n🧠 Auto-extracted Memories:", "info")
+            for mem in memories:
+                mem_type = mem.get('type', 'unknown')
+                content = mem.get('content', str(mem))[:50]
+                self.print_status(f"  • {mem_type}: {content}...", "info")
+        
+        return result
+    
+    def execute(self, text: str = None, user_id: str = None, **kwargs) -> Dict[str, Any]:
+        """
+        Execute auto memory extraction.
+        
+        Args:
+            text: Text to process
+            user_id: User ID for memory isolation
+            
+        Returns:
+            Dictionary of extracted memories
+        """
+        if not text:
+            return {}
+        
+        return self.extract_memories(text, user_id)