cognautic-cli 1.1.1__py3-none-any.whl

cognautic/provider_endpoints.py

@@ -0,0 +1,424 @@
+"""
+API Endpoints and configurations for all AI providers
+"""
+
+# Provider API Endpoints and Model Information
+PROVIDER_ENDPOINTS = {
+    "openai": {
+        "base_url": "https://api.openai.com/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "embeddings_endpoint": "/embeddings",
+        "audio_endpoint": "/audio",
+        "images_endpoint": "/images",
+        "files_endpoint": "/files",
+        "fine_tuning_endpoint": "/fine_tuning",
+        "moderations_endpoint": "/moderations",
+        "assistants_endpoint": "/assistants",
+        "threads_endpoint": "/threads",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "anthropic": {
+        "base_url": "https://api.anthropic.com",
+        "chat_endpoint": "/v1/messages",
+        "models_endpoint": "/v1/models",
+        "headers": {
+            "x-api-key": "{api_key}",
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01"
+        }
+    },
+    
+    "google": {
+        "base_url": "https://generativelanguage.googleapis.com",
+        "chat_endpoint": "/v1beta/models/{model}:generateContent",
+        "models_endpoint": "/v1beta/models",
+        "embeddings_endpoint": "/v1beta/models/{model}:embedContent",
+        "count_tokens_endpoint": "/v1beta/models/{model}:countTokens",
+        "headers": {
+            "Content-Type": "application/json"
+        },
+        "auth_param": "key={api_key}"
+    },
+    
+    "together": {
+        "base_url": "https://api.together.xyz/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "completions_endpoint": "/completions",
+        "embeddings_endpoint": "/embeddings",
+        "images_endpoint": "/images/generations",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "openrouter": {
+        "base_url": "https://openrouter.ai/api/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "auth_endpoint": "/auth/key",
+        "generation_endpoint": "/generation",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://cognautic-cli.local",
+            "X-Title": "Cognautic CLI"
+        }
+    },
+    
+    "huggingface": {
+        "base_url": "https://api-inference.huggingface.co",
+        "models_endpoint": "/models",
+        "inference_endpoint": "/models/{model}",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "cohere": {
+        "base_url": "https://api.cohere.ai/v1",
+        "chat_endpoint": "/chat",
+        "generate_endpoint": "/generate",
+        "embed_endpoint": "/embed",
+        "classify_endpoint": "/classify",
+        "summarize_endpoint": "/summarize",
+        "rerank_endpoint": "/rerank",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "replicate": {
+        "base_url": "https://api.replicate.com/v1",
+        "predictions_endpoint": "/predictions",
+        "models_endpoint": "/models",
+        "collections_endpoint": "/collections",
+        "headers": {
+            "Authorization": "Token {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "perplexity": {
+        "base_url": "https://api.perplexity.ai",
+        "chat_endpoint": "/chat/completions",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "mistral": {
+        "base_url": "https://api.mistral.ai/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "embeddings_endpoint": "/embeddings",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "groq": {
+        "base_url": "https://api.groq.com/openai/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "audio_endpoint": "/audio",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "deepseek": {
+        "base_url": "https://api.deepseek.com/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "fireworks": {
+        "base_url": "https://api.fireworks.ai/inference/v1",
+        "chat_endpoint": "/chat/completions",
+        "completions_endpoint": "/completions",
+        "embeddings_endpoint": "/embeddings",
+        "models_endpoint": "/models",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "anyscale": {
+        "base_url": "https://api.endpoints.anyscale.com/v1",
+        "chat_endpoint": "/chat/completions",
+        "models_endpoint": "/models",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "ai21": {
+        "base_url": "https://api.ai21.com/studio/v1",
+        "complete_endpoint": "/complete",
+        "chat_endpoint": "/chat/completions",
+        "tokenize_endpoint": "/tokenize",
+        "headers": {
+            "Authorization": "Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    },
+    
+    "palm": {
+        "base_url": "https://generativelanguage.googleapis.com/v1beta",
+        "generate_endpoint": "/models/{model}:generateText",
+        "chat_endpoint": "/models/{model}:generateMessage",
+        "embed_endpoint": "/models/{model}:embedText",
+        "models_endpoint": "/models",
+        "headers": {
+            "Content-Type": "application/json"
+        },
+        "auth_param": "key={api_key}"
+    },
+    
+    "claude": {
+        "base_url": "https://api.anthropic.com/v1",
+        "messages_endpoint": "/messages",
+        "complete_endpoint": "/complete",
+        "headers": {
+            "x-api-key": "{api_key}",
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01"
+        }
+    }
+}
+
+# Generic HTTP client for making API requests
+import aiohttp
+import json
+from typing import Dict, Any, Optional
+
+class GenericAPIClient:
+    """Generic API client that can work with any provider"""
+    
+    def __init__(self, provider_name: str, api_key: str):
+        self.provider_name = provider_name
+        self.api_key = api_key
+        self.config = PROVIDER_ENDPOINTS.get(provider_name, {})
+        
+    def get_headers(self) -> Dict[str, str]:
+        """Get headers with API key substituted"""
+        headers = self.config.get("headers", {}).copy()
+        for key, value in headers.items():
+            if isinstance(value, str) and "{api_key}" in value:
+                headers[key] = value.format(api_key=self.api_key)
+        return headers
+    
+    def get_url(self, endpoint_key: str, **kwargs) -> str:
+        """Get full URL for an endpoint"""
+        base_url = self.config.get("base_url", "")
+        endpoint = self.config.get(endpoint_key, "")
+        
+        # Format endpoint with any parameters (like model name)
+        if kwargs:
+            endpoint = endpoint.format(**kwargs)
+            
+        url = base_url + endpoint
+        
+        # Add auth parameter if needed (for Google/Palm)
+        if "auth_param" in self.config:
+            auth_param = self.config["auth_param"].format(api_key=self.api_key)
+            separator = "&" if "?" in url else "?"
+            url = f"{url}{separator}{auth_param}"
+            
+        return url
+    
+    async def make_request(self, endpoint_key: str, method: str = "POST", 
+                          data: Optional[Dict] = None, **url_kwargs) -> Dict[str, Any]:
+        """Make an API request to any endpoint"""
+        url = self.get_url(endpoint_key, **url_kwargs)
+        headers = self.get_headers()
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=data if data else None
+            ) as response:
+                if response.content_type == 'application/json':
+                    return await response.json()
+                else:
+                    text = await response.text()
+                    return {"text": text, "status": response.status}
+    
+    async def chat_completion(self, messages: list, model: str, **kwargs) -> Dict[str, Any]:
+        """Generic chat completion that works with most providers"""
+        
+        # Format messages based on provider
+        if self.provider_name == "google":
+            # Google Gemini format
+            data = {
+                "contents": [
+                    {
+                        "parts": [{"text": msg["content"]}],
+                        "role": "user" if msg["role"] == "user" else "model"
+                    }
+                    for msg in messages
+                ],
+                "generationConfig": {
+                    "temperature": kwargs.get("temperature", 0.7),
+                    "maxOutputTokens": kwargs.get("max_tokens", 8192)
+                }
+            }
+            return await self.make_request("chat_endpoint", data=data, model=model)
+            
+        elif self.provider_name == "anthropic":
+            # Anthropic Claude format
+            data = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": kwargs.get("max_tokens", 4096),
+                "temperature": kwargs.get("temperature", 0.7)
+            }
+            return await self.make_request("chat_endpoint", data=data)
+            
+        else:
+            # OpenAI-compatible format (works with most providers)
+            data = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": kwargs.get("max_tokens", 4096),
+                "temperature": kwargs.get("temperature", 0.7),
+                "stream": kwargs.get("stream", False)
+            }
+            return await self.make_request("chat_endpoint", data=data)
+    
+    async def list_models(self) -> Dict[str, Any]:
+        """List available models for the provider"""
+        return await self.make_request("models_endpoint", method="GET")
+
+def get_provider_config(provider_name: str) -> Dict[str, Any]:
+    """Get configuration for a specific provider"""
+    return PROVIDER_ENDPOINTS.get(provider_name, {})
+
+def get_all_providers() -> list:
+    """Get list of all supported providers"""
+    return list(PROVIDER_ENDPOINTS.keys())
+
+def get_provider_endpoints(provider_name: str) -> Dict[str, str]:
+    """Get all endpoints for a specific provider"""
+    config = PROVIDER_ENDPOINTS.get(provider_name, {})
+    return {k: v for k, v in config.items() if k.endswith("_endpoint")}
+
+# Popular models for each provider
+PROVIDER_MODELS = {
+    "openai": [
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-4-turbo",
+        "gpt-4",
+        "gpt-3.5-turbo",
+        "gpt-3.5-turbo-16k"
+    ],
+    "anthropic": [
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307"
+    ],
+    "google": [
+        "gemini-2.0-flash-exp",
+        "gemini-exp-1206",
+        "gemini-2.0-flash-thinking-exp-1219",
+        "gemini-exp-1121",
+        "gemini-1.5-pro",
+        "gemini-1.5-flash",
+        "gemini-1.5-flash-8b"
+    ],
+    "together": [
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "mistralai/Mistral-7B-Instruct-v0.2",
+        "Qwen/Qwen2.5-72B-Instruct-Turbo",
+        "deepseek-ai/deepseek-llm-67b-chat"
+    ],
+    "openrouter": [
+        "anthropic/claude-3.5-sonnet",
+        "openai/gpt-4-turbo",
+        "google/gemini-pro-1.5",
+        "meta-llama/llama-3.1-405b-instruct",
+        "mistralai/mixtral-8x22b-instruct"
+    ],
+    "groq": [
+        "llama-3.3-70b-versatile",
+        "llama-3.1-70b-versatile",
+        "llama-3.1-8b-instant",
+        "mixtral-8x7b-32768",
+        "gemma2-9b-it"
+    ],
+    "mistral": [
+        "mistral-large-latest",
+        "mistral-medium-latest",
+        "mistral-small-latest",
+        "open-mistral-7b",
+        "open-mixtral-8x7b",
+        "open-mixtral-8x22b"
+    ],
+    "deepseek": [
+        "deepseek-chat",
+        "deepseek-coder"
+    ],
+    "perplexity": [
+        "llama-3.1-sonar-small-128k-online",
+        "llama-3.1-sonar-large-128k-online",
+        "llama-3.1-sonar-huge-128k-online"
+    ],
+    "cohere": [
+        "command-r-plus",
+        "command-r",
+        "command",
+        "command-light"
+    ],
+    "fireworks": [
+        "accounts/fireworks/models/llama-v3p1-405b-instruct",
+        "accounts/fireworks/models/llama-v3p1-70b-instruct",
+        "accounts/fireworks/models/mixtral-8x7b-instruct"
+    ],
+    "huggingface": [
+        "meta-llama/Meta-Llama-3-70B-Instruct",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "google/gemma-7b-it"
+    ],
+    "replicate": [
+        "meta/llama-2-70b-chat",
+        "mistralai/mixtral-8x7b-instruct-v0.1"
+    ],
+    "anyscale": [
+        "meta-llama/Meta-Llama-3.1-70B-Instruct",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1"
+    ],
+    "ai21": [
+        "jamba-1.5-large",
+        "jamba-1.5-mini"
+    ]
+}
+
+def get_provider_models(provider_name: str) -> list:
+    """Get list of popular models for a provider"""
+    return PROVIDER_MODELS.get(provider_name, [])

cognautic/rules.py

@@ -0,0 +1,246 @@
+"""
+Rules management for Cognautic CLI
+Handles workspace-specific and global rules for AI behavior
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+console = Console()
+
+
+class RulesManager:
+    """Manages workspace and global rules for AI behavior"""
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".cognautic"
+        self.global_rules_file = self.config_dir / "global_rules.json"
+        self.workspace_rules_cache = {}
+        
+        # Create config directory if it doesn't exist
+        self.config_dir.mkdir(exist_ok=True)
+        
+        # Initialize global rules file if it doesn't exist
+        if not self.global_rules_file.exists():
+            self._save_global_rules([])
+    
+    def _get_workspace_rules_file(self, workspace_path: Optional[str] = None) -> Path:
+        """Get the workspace rules file path"""
+        if workspace_path:
+            workspace = Path(workspace_path).resolve()
+        else:
+            workspace = Path.cwd()
+        
+        return workspace / ".cognautic_rules.json"
+    
+    def _load_global_rules(self) -> List[Dict[str, Any]]:
+        """Load global rules from file"""
+        try:
+            if self.global_rules_file.exists():
+                with open(self.global_rules_file, 'r') as f:
+                    return json.load(f)
+            return []
+        except Exception as e:
+            console.print(f"⚠️ Error loading global rules: {e}", style="yellow")
+            return []
+    
+    def _save_global_rules(self, rules: List[Dict[str, Any]]):
+        """Save global rules to file"""
+        try:
+            with open(self.global_rules_file, 'w') as f:
+                json.dump(rules, f, indent=2)
+        except Exception as e:
+            console.print(f"❌ Error saving global rules: {e}", style="red")
+    
+    def _load_workspace_rules(self, workspace_path: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Load workspace-specific rules"""
+        rules_file = self._get_workspace_rules_file(workspace_path)
+        
+        try:
+            if rules_file.exists():
+                with open(rules_file, 'r') as f:
+                    return json.load(f)
+            return []
+        except Exception as e:
+            console.print(f"⚠️ Error loading workspace rules: {e}", style="yellow")
+            return []
+    
+    def _save_workspace_rules(self, rules: List[Dict[str, Any]], workspace_path: Optional[str] = None):
+        """Save workspace-specific rules"""
+        rules_file = self._get_workspace_rules_file(workspace_path)
+        
+        try:
+            with open(rules_file, 'w') as f:
+                json.dump(rules, f, indent=2)
+            console.print(f"✅ Workspace rules saved to: {rules_file}", style="green")
+        except Exception as e:
+            console.print(f"❌ Error saving workspace rules: {e}", style="red")
+    
+    def add_global_rule(self, rule: str, description: str = "") -> bool:
+        """Add a global rule"""
+        rules = self._load_global_rules()
+        
+        # Check if rule already exists
+        for existing_rule in rules:
+            if existing_rule.get('rule') == rule:
+                console.print("⚠️ This rule already exists in global rules", style="yellow")
+                return False
+        
+        rules.append({
+            'rule': rule,
+            'description': description,
+            'type': 'global'
+        })
+        
+        self._save_global_rules(rules)
+        console.print("✅ Global rule added successfully", style="green")
+        return True
+    
+    def add_workspace_rule(self, rule: str, description: str = "", workspace_path: Optional[str] = None) -> bool:
+        """Add a workspace-specific rule"""
+        rules = self._load_workspace_rules(workspace_path)
+        
+        # Check if rule already exists
+        for existing_rule in rules:
+            if existing_rule.get('rule') == rule:
+                console.print("⚠️ This rule already exists in workspace rules", style="yellow")
+                return False
+        
+        rules.append({
+            'rule': rule,
+            'description': description,
+            'type': 'workspace'
+        })
+        
+        self._save_workspace_rules(rules, workspace_path)
+        console.print("✅ Workspace rule added successfully", style="green")
+        return True
+    
+    def remove_global_rule(self, rule_index: int) -> bool:
+        """Remove a global rule by index"""
+        rules = self._load_global_rules()
+        
+        if 0 <= rule_index < len(rules):
+            removed = rules.pop(rule_index)
+            self._save_global_rules(rules)
+            console.print(f"✅ Removed global rule: {removed['rule']}", style="green")
+            return True
+        else:
+            console.print("❌ Invalid rule index", style="red")
+            return False
+    
+    def remove_workspace_rule(self, rule_index: int, workspace_path: Optional[str] = None) -> bool:
+        """Remove a workspace rule by index"""
+        rules = self._load_workspace_rules(workspace_path)
+        
+        if 0 <= rule_index < len(rules):
+            removed = rules.pop(rule_index)
+            self._save_workspace_rules(rules, workspace_path)
+            console.print(f"✅ Removed workspace rule: {removed['rule']}", style="green")
+            return True
+        else:
+            console.print("❌ Invalid rule index", style="red")
+            return False
+    
+    def list_global_rules(self) -> List[Dict[str, Any]]:
+        """List all global rules"""
+        return self._load_global_rules()
+    
+    def list_workspace_rules(self, workspace_path: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List all workspace rules"""
+        return self._load_workspace_rules(workspace_path)
+    
+    def get_all_rules(self, workspace_path: Optional[str] = None) -> Dict[str, List[Dict[str, Any]]]:
+        """Get both global and workspace rules"""
+        return {
+            'global': self._load_global_rules(),
+            'workspace': self._load_workspace_rules(workspace_path)
+        }
+    
+    def get_rules_for_ai(self, workspace_path: Optional[str] = None) -> str:
+        """Get formatted rules for AI context"""
+        all_rules = self.get_all_rules(workspace_path)
+        
+        rules_text = []
+        
+        # Add global rules
+        if all_rules['global']:
+            rules_text.append("# Global Rules")
+            for i, rule in enumerate(all_rules['global'], 1):
+                rules_text.append(f"{i}. {rule['rule']}")
+                if rule.get('description'):
+                    rules_text.append(f"   Description: {rule['description']}")
+        
+        # Add workspace rules
+        if all_rules['workspace']:
+            if rules_text:
+                rules_text.append("")
+            rules_text.append("# Workspace Rules")
+            for i, rule in enumerate(all_rules['workspace'], 1):
+                rules_text.append(f"{i}. {rule['rule']}")
+                if rule.get('description'):
+                    rules_text.append(f"   Description: {rule['description']}")
+        
+        return "\n".join(rules_text) if rules_text else ""
+    
+    def display_rules(self, workspace_path: Optional[str] = None):
+        """Display all rules in a formatted table"""
+        all_rules = self.get_all_rules(workspace_path)
+        
+        # Display global rules
+        if all_rules['global']:
+            console.print(Panel.fit("🌍 Global Rules", style="bold blue"))
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("#", style="dim", width=4)
+            table.add_column("Rule", style="white")
+            table.add_column("Description", style="dim")
+            
+            for i, rule in enumerate(all_rules['global']):
+                table.add_row(
+                    str(i),
+                    rule['rule'],
+                    rule.get('description', '')
+                )
+            
+            console.print(table)
+            console.print()
+        else:
+            console.print("📝 No global rules defined", style="dim")
+            console.print()
+        
+        # Display workspace rules
+        if all_rules['workspace']:
+            workspace_display = workspace_path or os.getcwd()
+            console.print(Panel.fit(f"📁 Workspace Rules ({workspace_display})", style="bold green"))
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("#", style="dim", width=4)
+            table.add_column("Rule", style="white")
+            table.add_column("Description", style="dim")
+            
+            for i, rule in enumerate(all_rules['workspace']):
+                table.add_row(
+                    str(i),
+                    rule['rule'],
+                    rule.get('description', '')
+                )
+            
+            console.print(table)
+        else:
+            console.print(f"📝 No workspace rules defined for current workspace", style="dim")
+    
+    def clear_global_rules(self) -> bool:
+        """Clear all global rules"""
+        self._save_global_rules([])
+        console.print("✅ All global rules cleared", style="green")
+        return True
+    
+    def clear_workspace_rules(self, workspace_path: Optional[str] = None) -> bool:
+        """Clear all workspace rules"""
+        self._save_workspace_rules([], workspace_path)
+        console.print("✅ All workspace rules cleared", style="green")
+        return True

cognautic/tools/__init__.py

@@ -0,0 +1,19 @@
+"""
+Tool system for Cognautic CLI
+"""
+
+from .registry import ToolRegistry
+from .file_operations import FileOperationsTool
+from .command_runner import CommandRunnerTool
+from .web_search import WebSearchTool
+from .code_analysis import CodeAnalysisTool
+from .response_control import ResponseControlTool
+
+__all__ = [
+    'ToolRegistry',
+    'FileOperationsTool', 
+    'CommandRunnerTool',
+    'WebSearchTool',
+    'CodeAnalysisTool',
+    'ResponseControlTool'
+]