cognautic-cli 1.1.1__py3-none-any.whl

cognautic/config.py

@@ -0,0 +1,245 @@
+"""
+Configuration management for Cognautic CLI
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+from cryptography.fernet import Fernet
+import keyring
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+
+console = Console()
+
+class ConfigManager:
+    """Manages configuration and secure API key storage"""
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".cognautic"
+        self.config_file = self.config_dir / "config.json"
+        self.api_keys_file = self.config_dir / "api_keys.json"
+        
+        # Create config directory if it doesn't exist
+        self.config_dir.mkdir(exist_ok=True)
+        
+        # Default configuration
+        self.default_config = {
+            "default_provider": "openai",
+            "default_model": "gpt-4",
+            "websocket_port": 8765,
+            "max_tokens": 4096,
+            "temperature": 0.7,
+            "auto_save": True,
+            "verbose_logging": False,
+            "provider_models": {}  # Store model selection per provider
+        }
+        
+        # Initialize configuration
+        self._init_config()
+        
+        # Initialize encryption key
+        self._init_encryption()
+    
+    def _init_config(self):
+        """Initialize configuration file with defaults"""
+        if not self.config_file.exists():
+            self._save_config(self.default_config)
+    
+    def _init_encryption(self):
+        """Initialize encryption for API keys"""
+        try:
+            # Try to get existing key from keyring
+            key = keyring.get_password("cognautic", "encryption_key")
+            if not key:
+                # Generate new key
+                key = Fernet.generate_key().decode()
+                keyring.set_password("cognautic", "encryption_key", key)
+            
+            self.cipher = Fernet(key.encode())
+        except Exception:
+            # Silently fallback to no encryption if keyring is not available
+            self.cipher = None
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Get current configuration"""
+        try:
+            with open(self.config_file, 'r') as f:
+                return json.load(f)
+        except Exception:
+            return self.default_config.copy()
+    
+    def get_config_value(self, key: str) -> Any:
+        """Get a specific configuration value"""
+        config = self.get_config()
+        return config.get(key)
+    
+    def set_config(self, key: str, value: Any):
+        """Set a configuration value"""
+        config = self.get_config()
+        config[key] = value
+        self._save_config(config)
+    
+    def delete_config(self, key: str):
+        """Delete a configuration key"""
+        config = self.get_config()
+        if key in config:
+            del config[key]
+            self._save_config(config)
+    
+    def reset_config(self):
+        """Reset configuration to defaults"""
+        self._save_config(self.default_config.copy())
+    
+    def _save_config(self, config: Dict[str, Any]):
+        """Save configuration to file"""
+        try:
+            with open(self.config_file, 'w') as f:
+                json.dump(config, f, indent=2)
+        except Exception as e:
+            console.print(f"❌ Error saving configuration: {e}", style="red")
+    
+    def set_api_key(self, provider: str, api_key: str):
+        """Set API key for a provider"""
+        try:
+            # Load existing API keys
+            api_keys = self._load_api_keys()
+            
+            # Encrypt the API key if encryption is available
+            if self.cipher:
+                encrypted_key = self.cipher.encrypt(api_key.encode()).decode()
+                api_keys[provider] = encrypted_key
+            else:
+                api_keys[provider] = api_key
+            
+            # Save API keys
+            self._save_api_keys(api_keys)
+            
+        except Exception as e:
+            console.print(f"❌ Error saving API key: {e}", style="red")
+    
+    def get_api_key(self, provider: str) -> Optional[str]:
+        """Get API key for a provider"""
+        try:
+            # Ensure provider is a string
+            if not isinstance(provider, str):
+                return None
+                
+            # First check environment variables
+            env_var = f"{provider.upper()}_API_KEY"
+            if env_var in os.environ:
+                return os.environ[env_var]
+            
+            # Then check stored keys
+            api_keys = self._load_api_keys()
+            encrypted_key = api_keys.get(provider)
+            
+            if not encrypted_key:
+                return None
+            
+            # Decrypt the API key if encryption is available
+            if self.cipher:
+                try:
+                    return self.cipher.decrypt(encrypted_key.encode()).decode()
+                except Exception:
+                    # If decryption fails, assume it's unencrypted (backward compatibility)
+                    return encrypted_key
+            else:
+                return encrypted_key
+                
+        except Exception as e:
+            console.print(f"❌ Error loading API key: {e}", style="red")
+            return None
+    
+    def has_api_key(self, provider: str) -> bool:
+        """Check if API key exists for a provider"""
+        return self.get_api_key(provider) is not None
+    
+    def list_providers(self) -> list:
+        """List all configured providers"""
+        api_keys = self._load_api_keys()
+        env_providers = [
+            key.replace('_API_KEY', '').lower() 
+            for key in os.environ.keys() 
+            if key.endswith('_API_KEY')
+        ]
+        return list(set(list(api_keys.keys()) + env_providers))
+    
+    def _load_api_keys(self) -> Dict[str, str]:
+        """Load API keys from file"""
+        try:
+            if self.api_keys_file.exists():
+                with open(self.api_keys_file, 'r') as f:
+                    return json.load(f)
+            return {}
+        except Exception:
+            return {}
+    
+    def _save_api_keys(self, api_keys: Dict[str, str]):
+        """Save API keys to file"""
+        try:
+            with open(self.api_keys_file, 'w') as f:
+                json.dump(api_keys, f, indent=2)
+            
+            # Set secure file permissions
+            os.chmod(self.api_keys_file, 0o600)
+            
+        except Exception as e:
+            console.print(f"❌ Error saving API keys: {e}", style="red")
+    
+    def set_provider_model(self, provider: str, model: str):
+        """Set the preferred model for a specific provider"""
+        config = self.get_config()
+        if 'provider_models' not in config:
+            config['provider_models'] = {}
+        config['provider_models'][provider] = model
+        self._save_config(config)
+    
+    def get_provider_model(self, provider: str) -> Optional[str]:
+        """Get the preferred model for a specific provider"""
+        config = self.get_config()
+        provider_models = config.get('provider_models', {})
+        return provider_models.get(provider)
+    
+    def interactive_setup(self):
+        """Interactive setup wizard"""
+        console.print("🔧 Cognautic CLI Interactive Setup", style="bold blue")
+        console.print("This wizard will help you configure API keys for AI providers.\n")
+        
+        providers = [
+            ("openai", "OpenAI", "OPENAI_API_KEY"),
+            ("anthropic", "Anthropic", "ANTHROPIC_API_KEY"),
+            ("google", "Google", "GOOGLE_API_KEY"),
+            ("together", "Together AI", "TOGETHER_API_KEY"),
+            ("openrouter", "OpenRouter", "OPENROUTER_API_KEY")
+        ]
+        
+        for provider_id, provider_name, env_var in providers:
+            if Confirm.ask(f"Configure {provider_name}?"):
+                console.print(f"Get your API key from the {provider_name} dashboard")
+                console.print(f"Environment variable: {env_var}")
+                
+                api_key = Prompt.ask(f"Enter {provider_name} API key", password=True)
+                if api_key:
+                    self.set_api_key(provider_id, api_key)
+                    console.print(f"✅ {provider_name} API key saved", style="green")
+                else:
+                    console.print(f"⏭️ Skipping {provider_name}", style="yellow")
+                
+                console.print()
+        
+        # Configure default provider
+        configured_providers = self.list_providers()
+        if configured_providers:
+            console.print("Available providers:", ", ".join(configured_providers))
+            default_provider = Prompt.ask(
+                "Choose default provider", 
+                choices=configured_providers,
+                default=configured_providers[0]
+            )
+            self.set_config("default_provider", default_provider)
+            console.print(f"✅ Default provider set to {default_provider}", style="green")
+        
+        console.print("\n🎉 Setup complete! You can now use Cognautic CLI.", style="bold green")
+        console.print("Try: cognautic chat --help")

cognautic/file_tagger.py

@@ -0,0 +1,194 @@
+"""
+File tagging system for referencing files in AI conversations
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional
+import fnmatch
+
+
+class FileTag:
+    """Represents a file tag with its path and content"""
+    
+    def __init__(self, tag: str, file_path: str, content: str = None, exists: bool = True):
+        self.tag = tag  # Original @tag from user input
+        self.file_path = file_path  # Resolved absolute path
+        self.content = content  # File content (loaded lazily)
+        self.exists = exists  # Whether file exists
+        self.relative_path = None  # Relative path from workspace
+    
+    def load_content(self) -> str:
+        """Load file content if not already loaded"""
+        if self.content is None and self.exists:
+            try:
+                with open(self.file_path, 'r', encoding='utf-8') as f:
+                    self.content = f.read()
+            except Exception as e:
+                self.content = f"Error reading file: {str(e)}"
+                self.exists = False
+        return self.content or ""
+
+
+class FileTagger:
+    """Handles file tagging and resolution"""
+    
+    def __init__(self, workspace_path: str = None):
+        self.workspace_path = Path(workspace_path).resolve() if workspace_path else None
+    
+    def find_file_tags(self, text: str) -> List[str]:
+        """Find all @file tags in text"""
+        # Match @filename, @path/filename, @./filename, @../filename, @/absolute/path
+        pattern = r'@([a-zA-Z0-9._/-]+(?:\.[a-zA-Z0-9]+)?)'
+        matches = re.findall(pattern, text)
+        return [f"@{match}" for match in matches]
+    
+    def resolve_file_path(self, tag: str) -> Tuple[str, bool]:
+        """Resolve a file tag to an absolute path"""
+        # Remove @ prefix
+        file_ref = tag[1:] if tag.startswith('@') else tag
+        
+        # Handle different path types
+        if os.path.isabs(file_ref):
+            # Absolute path
+            resolved_path = Path(file_ref).resolve()
+        elif file_ref.startswith('./') or file_ref.startswith('../'):
+            # Relative path from current working directory
+            resolved_path = Path(file_ref).resolve()
+        elif self.workspace_path and '/' not in file_ref:
+            # Simple filename - look in workspace root first
+            resolved_path = self.workspace_path / file_ref
+            if not resolved_path.exists():
+                # If not found in workspace, try current directory
+                resolved_path = Path(file_ref).resolve()
+        elif self.workspace_path:
+            # Relative path from workspace
+            resolved_path = self.workspace_path / file_ref
+        else:
+            # No workspace, treat as relative to current directory
+            resolved_path = Path(file_ref).resolve()
+        
+        return str(resolved_path), resolved_path.exists()
+    
+    def get_file_suggestions(self, partial_path: str = "", limit: int = 20) -> List[str]:
+        """Get file suggestions for autocompletion"""
+        suggestions = []
+        
+        # Get files from workspace if available
+        if self.workspace_path and self.workspace_path.exists():
+            suggestions.extend(self._get_workspace_suggestions(partial_path, limit // 2))
+        
+        # Get files from current directory
+        suggestions.extend(self._get_current_dir_suggestions(partial_path, limit // 2))
+        
+        return list(set(suggestions))[:limit]
+    
+    def _get_workspace_suggestions(self, partial_path: str, limit: int) -> List[str]:
+        """Get file suggestions from workspace"""
+        suggestions = []
+        try:
+            if not partial_path:
+                # Show files in workspace root
+                for item in self.workspace_path.iterdir():
+                    if item.is_file() and not item.name.startswith('.'):
+                        suggestions.append(item.name)
+            else:
+                # Search for matching files - both prefix and contains matches
+                # First, try exact prefix matches
+                for item in self.workspace_path.rglob("*"):
+                    if item.is_file() and not any(part.startswith('.') for part in item.parts):
+                        rel_path = item.relative_to(self.workspace_path)
+                        rel_path_str = str(rel_path)
+                        # Check if filename starts with partial_path
+                        if item.name.startswith(partial_path) or rel_path_str.startswith(partial_path):
+                            suggestions.append(rel_path_str)
+                
+                # If no prefix matches, try contains matches
+                if not suggestions:
+                    pattern = f"*{partial_path}*"
+                    for item in self.workspace_path.rglob(pattern):
+                        if item.is_file() and not any(part.startswith('.') for part in item.parts):
+                            rel_path = item.relative_to(self.workspace_path)
+                            suggestions.append(str(rel_path))
+        except Exception:
+            pass
+        
+        return suggestions[:limit]
+    
+    def _get_current_dir_suggestions(self, partial_path: str, limit: int) -> List[str]:
+        """Get file suggestions from current directory"""
+        suggestions = []
+        try:
+            current_dir = Path.cwd()
+            if not partial_path:
+                # Show files in current directory
+                for item in current_dir.iterdir():
+                    if item.is_file() and not item.name.startswith('.'):
+                        suggestions.append(f"./{item.name}")
+            else:
+                # Search for matching files - prefix matches first
+                for item in current_dir.rglob("*"):
+                    if item.is_file() and not any(part.startswith('.') for part in item.parts):
+                        rel_path = item.relative_to(current_dir)
+                        rel_path_str = str(rel_path)
+                        # Check if filename starts with partial_path
+                        if item.name.startswith(partial_path) or rel_path_str.startswith(partial_path):
+                            suggestions.append(f"./{rel_path_str}")
+                
+                # If no prefix matches, try contains matches
+                if not suggestions:
+                    pattern = f"*{partial_path}*"
+                    for item in current_dir.rglob(pattern):
+                        if item.is_file() and not any(part.startswith('.') for part in item.parts):
+                            rel_path = item.relative_to(current_dir)
+                            suggestions.append(f"./{rel_path}")
+        except Exception:
+            pass
+        
+        return suggestions[:limit]
+    
+    def process_message_with_tags(self, message: str) -> Tuple[str, List[FileTag]]:
+        """Process a message and resolve all file tags"""
+        tags = self.find_file_tags(message)
+        file_tags = []
+        processed_message = message
+        
+        for tag in tags:
+            file_path, exists = self.resolve_file_path(tag)
+            file_tag = FileTag(tag, file_path, exists=exists)
+            
+            # Set relative path if in workspace
+            if self.workspace_path and file_path.startswith(str(self.workspace_path)):
+                file_tag.relative_path = str(Path(file_path).relative_to(self.workspace_path))
+            
+            file_tags.append(file_tag)
+        
+        return processed_message, file_tags
+    
+    def format_file_context(self, file_tags: List[FileTag]) -> str:
+        """Format file tags into context for AI"""
+        if not file_tags:
+            return ""
+        
+        context_parts = ["## Referenced Files:\n"]
+        
+        for file_tag in file_tags:
+            if file_tag.exists:
+                content = file_tag.load_content()
+                display_path = file_tag.relative_path or file_tag.file_path
+                
+                context_parts.append(f"### {file_tag.tag} ({display_path})")
+                context_parts.append("```")
+                context_parts.append(content)
+                context_parts.append("```\n")
+            else:
+                context_parts.append(f"### {file_tag.tag} (FILE NOT FOUND)")
+                context_parts.append(f"Path: {file_tag.file_path}\n")
+        
+        return "\n".join(context_parts)
+
+
+def create_file_tagger(workspace_path: str = None) -> FileTagger:
+    """Create a FileTagger instance"""
+    return FileTagger(workspace_path)