kubrick-cli 0.1.4__py3-none-any.whl

kubrick_cli/config.py

@@ -0,0 +1,247 @@
+"""Configuration management for Kubrick CLI."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class KubrickConfig:
+    """Manages Kubrick configuration and data directories."""
+
+    def __init__(self, skip_wizard: bool = False):
+        """
+        Initialize config manager and ensure directories exist.
+
+        Args:
+            skip_wizard: Skip setup wizard even if config doesn't exist (for testing)
+        """
+        # Use ~/.kubrick in all environments (Docker and non-Docker)
+        # In Docker, this resolves to /home/kubrick/.kubrick
+        # Outside Docker, this resolves to the current user's home directory
+        self.kubrick_dir = Path.home() / ".kubrick"
+        self.config_file = self.kubrick_dir / "config.json"
+        self.conversations_dir = self.kubrick_dir / "conversations"
+
+        self._ensure_directories()
+
+        self.config = self._load_config(skip_wizard=skip_wizard)
+
+    def _ensure_directories(self):
+        """Create necessary directories if they don't exist."""
+        self.kubrick_dir.mkdir(exist_ok=True)
+        self.conversations_dir.mkdir(exist_ok=True)
+
+    def _load_config(self, skip_wizard: bool = False) -> Dict[str, Any]:
+        """
+        Load configuration from file or create default.
+
+        Args:
+            skip_wizard: Skip setup wizard even if config doesn't exist
+
+        Returns:
+            Configuration dictionary
+        """
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, "r") as f:
+                    loaded_config = json.load(f)
+
+                default_config = self._get_default_config()
+                default_config.update(loaded_config)
+                return default_config
+
+            except (json.JSONDecodeError, IOError):
+                return self._get_default_config()
+        else:
+            if not skip_wizard:
+                from .setup_wizard import SetupWizard
+
+                wizard_config = SetupWizard.run()
+
+                config = self._get_default_config()
+                config.update(wizard_config)
+
+                self._save_config(config)
+                return config
+            else:
+                config = self._get_default_config()
+                self._save_config(config)
+                return config
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration values."""
+        return {
+            # Provider settings
+            "provider": "triton",
+            # Triton settings
+            "triton_url": "localhost:8000",
+            "triton_model": "llm_decoupled",
+            # OpenAI settings
+            "openai_api_key": None,
+            "openai_model": "gpt-4",
+            # Anthropic settings
+            "anthropic_api_key": None,
+            "anthropic_model": "claude-sonnet-4-5-20250929",
+            # Legacy compatibility
+            "model_name": "llm_decoupled",
+            "use_openai": False,
+            "default_working_dir": None,
+            # Agent loop settings
+            "max_iterations": 15,
+            "max_tools_per_turn": 5,
+            "total_timeout_seconds": 600,
+            "enable_parallel_tools": True,
+            "max_parallel_workers": 3,
+            # Safety settings
+            "require_dangerous_command_confirmation": True,
+            "tool_timeout_seconds": 30,
+            "max_file_size_mb": 10,
+            # Display settings
+            "display_mode": "natural",
+            "show_tool_results": True,
+            "show_progress": True,
+            # Task classification settings
+            "enable_task_classification": True,
+            "enable_planning_phase": True,
+            # Conversation settings
+            "auto_save_conversations": True,
+            "max_conversations": 100,
+        }
+
+    def _save_config(self, config: Dict[str, Any]):
+        """Save configuration to file."""
+        with open(self.config_file, "w") as f:
+            json.dump(config, f, indent=2)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a configuration value."""
+        return self.config.get(key, default)
+
+    def set(self, key: str, value: Any):
+        """Set a configuration value and save."""
+        self.config[key] = value
+        self._save_config(self.config)
+
+    def get_all(self) -> Dict[str, Any]:
+        """Get all configuration values."""
+        return self.config.copy()
+
+    def save_conversation(
+        self, conversation_id: str, messages: list, metadata: Dict = None
+    ):
+        """
+        Save a conversation to disk.
+
+        Args:
+            conversation_id: Unique identifier for the conversation (e.g., timestamp)
+            messages: List of message dictionaries
+            metadata: Optional metadata (working_dir, triton_url, etc.)
+        """
+        conversation_file = self.conversations_dir / f"{conversation_id}.json"
+
+        data = {
+            "id": conversation_id,
+            "messages": messages,
+            "metadata": metadata or {},
+        }
+
+        with open(conversation_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+        self._cleanup_old_conversations()
+
+    def load_conversation(self, conversation_id: str) -> Optional[Dict]:
+        """
+        Load a conversation from disk.
+
+        Supports two modes:
+        1. By ID: Loads from ~/.kubrick/conversations/<id>.json
+        2. By path: Loads from absolute or relative file path
+
+        Args:
+            conversation_id: Conversation ID or file path
+
+        Returns:
+            Dictionary with 'id', 'messages', and 'metadata', or None if not found
+        """
+        if (
+            "/" in conversation_id
+            or "\\" in conversation_id
+            or conversation_id.endswith(".json")
+        ):
+            conversation_file = Path(conversation_id).expanduser().resolve()
+        else:
+            conversation_file = self.conversations_dir / f"{conversation_id}.json"
+
+        if not conversation_file.exists():
+            return None
+
+        try:
+            with open(conversation_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return None
+
+    def list_conversations(self, limit: int = None) -> list:
+        """
+        List all saved conversations.
+
+        Args:
+            limit: Optional limit on number of conversations to return
+
+        Returns:
+            List of conversation metadata sorted by modification time (newest first)
+        """
+        conversations = []
+
+        for conv_file in self.conversations_dir.glob("*.json"):
+            try:
+                with open(conv_file, "r") as f:
+                    data = json.load(f)
+
+                conversations.append(
+                    {
+                        "id": data.get("id", conv_file.stem),
+                        "metadata": data.get("metadata", {}),
+                        "message_count": len(data.get("messages", [])),
+                        "modified": conv_file.stat().st_mtime,
+                    }
+                )
+            except (json.JSONDecodeError, IOError):
+                continue
+
+        conversations.sort(key=lambda x: x["modified"], reverse=True)
+
+        if limit:
+            conversations = conversations[:limit]
+
+        return conversations
+
+    def delete_conversation(self, conversation_id: str) -> bool:
+        """
+        Delete a conversation.
+
+        Args:
+            conversation_id: Unique identifier for the conversation
+
+        Returns:
+            True if deleted, False if not found
+        """
+        conversation_file = self.conversations_dir / f"{conversation_id}.json"
+
+        if conversation_file.exists():
+            conversation_file.unlink()
+            return True
+        return False
+
+    def _cleanup_old_conversations(self):
+        """Remove oldest conversations if we exceed max_conversations."""
+        max_conversations = self.config.get("max_conversations", 100)
+
+        conversations = list(self.conversations_dir.glob("*.json"))
+
+        if len(conversations) > max_conversations:
+            conversations.sort(key=lambda x: x.stat().st_mtime)
+
+            for conv_file in conversations[: len(conversations) - max_conversations]:
+                conv_file.unlink()

kubrick_cli/display.py

@@ -0,0 +1,154 @@
+"""Display manager for natural language tool output."""
+
+import json
+from typing import Any, Dict
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+console = Console()
+
+
+class DisplayManager:
+    """
+    Manages display of tool calls and results in natural language.
+
+    Supports multiple display modes:
+    - natural: Human-friendly descriptions (default)
+    - json: Raw JSON panels (old behavior)
+    - verbose: Both natural + JSON
+    """
+
+    def __init__(self, config: Dict):
+        """
+        Initialize display manager.
+
+        Args:
+            config: Configuration dict with display settings
+        """
+        self.display_mode = config.get("display_mode", "natural")
+        self.show_tool_results = config.get("show_tool_results", True)
+
+    def display_tool_call(self, tool_name: str, parameters: Dict[str, Any]):
+        """
+        Display a tool call in the configured mode.
+
+        Args:
+            tool_name: Name of the tool being called
+            parameters: Tool parameters
+        """
+        if self.display_mode == "natural":
+            self._display_natural_tool_call(tool_name, parameters)
+        elif self.display_mode == "json":
+            self._display_json_tool_call(tool_name, parameters)
+        elif self.display_mode == "verbose":
+            self._display_natural_tool_call(tool_name, parameters)
+            self._display_json_tool_call(tool_name, parameters)
+
+    def display_tool_result(
+        self, tool_name: str, result: Dict[str, Any], success: bool
+    ):
+        """
+        Display a tool execution result.
+
+        Args:
+            tool_name: Name of the tool that was executed
+            result: Result dictionary
+            success: Whether the execution succeeded
+        """
+        if not self.show_tool_results:
+            return
+
+        if self.display_mode == "natural":
+            self._display_natural_result(tool_name, result, success)
+        elif self.display_mode in ("json", "verbose"):
+            self._display_json_result(tool_name, result, success)
+
+    def _display_natural_tool_call(self, tool_name: str, parameters: Dict[str, Any]):
+        """Display tool call in natural language."""
+        description = self._get_natural_description(tool_name, parameters)
+        console.print(f"[cyan]→ {description}[/cyan]")
+
+    def _display_json_tool_call(self, tool_name: str, parameters: Dict[str, Any]):
+        """Display tool call as JSON panel."""
+        tool_data = {"tool": tool_name, "parameters": parameters}
+        json_str = json.dumps(tool_data, indent=2)
+        syntax = Syntax(json_str, "json", theme="monokai", line_numbers=False)
+        console.print(Panel(syntax, title="Tool Call", border_style="cyan"))
+
+    def _display_natural_result(
+        self, tool_name: str, result: Dict[str, Any], success: bool
+    ):
+        """Display result in natural language."""
+        if success:
+            result_text = result.get("result", "")
+
+            if len(result_text) > 200:
+                preview = result_text[:200] + "..."
+                console.print(f"[green]✓ {tool_name} succeeded[/green]")
+                console.print(f"[dim]{preview}[/dim]")
+            else:
+                console.print(f"[green]✓ {tool_name} succeeded[/green]")
+        else:
+            error = result.get("error", "Unknown error")
+            console.print(f"[red]✗ {tool_name} failed: {error}[/red]")
+
+    def _display_json_result(
+        self, tool_name: str, result: Dict[str, Any], success: bool
+    ):
+        """Display result as JSON panel."""
+        json_str = json.dumps(result, indent=2)
+        syntax = Syntax(json_str, "json", theme="monokai", line_numbers=False)
+        border_style = "green" if success else "red"
+        title = f"Result: {tool_name}"
+        console.print(Panel(syntax, title=title, border_style=border_style))
+
+    def _get_natural_description(
+        self, tool_name: str, parameters: Dict[str, Any]
+    ) -> str:
+        """
+        Generate natural language description for a tool call.
+
+        Args:
+            tool_name: Name of the tool
+            parameters: Tool parameters
+
+        Returns:
+            Human-friendly description
+        """
+        if tool_name == "read_file":
+            file_path = parameters.get("file_path", "unknown")
+            return f"Reading {file_path}"
+
+        elif tool_name == "write_file":
+            file_path = parameters.get("file_path", "unknown")
+            content_length = len(parameters.get("content", ""))
+            return f"Writing {content_length} characters to {file_path}"
+
+        elif tool_name == "edit_file":
+            file_path = parameters.get("file_path", "unknown")
+            return f"Editing {file_path}"
+
+        elif tool_name == "list_files":
+            pattern = parameters.get("pattern", "*")
+            directory = parameters.get("directory", ".")
+            return f"Listing files matching '{pattern}' in {directory}"
+
+        elif tool_name == "search_files":
+            pattern = parameters.get("pattern", "")
+            file_pattern = parameters.get("file_pattern", "**/*")
+            return f"Searching for '{pattern}' in files matching '{file_pattern}'"
+
+        elif tool_name == "run_bash":
+            command = parameters.get("command", "")
+            if len(command) > 60:
+                command = command[:60] + "..."
+            return f"Running bash command: {command}"
+
+        elif tool_name == "create_directory":
+            path = parameters.get("path", "unknown")
+            return f"Creating directory {path}"
+
+        else:
+            return f"Calling {tool_name}"

kubrick_cli/execution_strategy.py

@@ -0,0 +1,195 @@
+"""Execution strategy configuration based on task complexity."""
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+from .classifier import TaskClassification
+
+
+@dataclass
+class ExecutionConfig:
+    """Configuration for task execution."""
+
+    mode: str  # "conversational", "agentic_simple", "agentic_complex"
+    max_iterations: int
+    use_agent_loop: bool
+    use_planning: bool
+    model_tier: str  # "fast", "balanced", "best"
+    temperature: float
+    max_tokens: Optional[int]
+    hyperparameters: Dict
+
+
+class ExecutionStrategy:
+    """
+    Determines execution strategy based on task classification.
+
+    Optimizes for:
+    - Cost (use smaller models for simple tasks)
+    - Speed (fewer iterations for simple tasks)
+    - Quality (best models for complex tasks)
+    """
+
+    MODEL_TIERS = {
+        "openai": {
+            "fast": "gpt-3.5-turbo",
+            "balanced": "gpt-4",
+            "best": "gpt-4",
+        },
+        "anthropic": {
+            "fast": "claude-haiku-4-5-20251001",
+            "balanced": "claude-sonnet-4-5-20250929",
+            "best": "claude-opus-4-1-20250805",
+        },
+        "triton": {
+            "fast": None,
+            "balanced": None,
+            "best": None,
+        },
+    }
+
+    @staticmethod
+    def get_execution_config(
+        classification: Optional[TaskClassification],
+        provider_name: str,
+        default_model: str,
+    ) -> ExecutionConfig:
+        """
+        Get execution configuration based on task classification.
+
+        Args:
+            classification: Task classification result (None for fallback)
+            provider_name: Provider name (triton, openai, anthropic)
+            default_model: Default model name from config
+
+        Returns:
+            ExecutionConfig with optimized settings
+        """
+        # Handle None classification (fallback to simple)
+        if classification is None:
+            return ExecutionStrategy._simple_config(provider_name, default_model)
+
+        complexity = classification.complexity
+
+        if complexity == "CONVERSATIONAL":
+            return ExecutionStrategy._conversational_config(
+                provider_name, default_model
+            )
+        elif complexity == "SIMPLE":
+            return ExecutionStrategy._simple_config(provider_name, default_model)
+        elif complexity == "COMPLEX":
+            return ExecutionStrategy._complex_config(provider_name, default_model)
+        else:
+            # Fallback to simple
+            return ExecutionStrategy._simple_config(provider_name, default_model)
+
+    @staticmethod
+    def _conversational_config(
+        provider_name: str, default_model: str
+    ) -> ExecutionConfig:
+        """
+        Configuration for conversational tasks.
+
+        - Single-turn response
+        - No agent loop
+        - Fast/cheap model
+        - Higher temperature for creativity
+        """
+        # Get fast model for provider
+        model_tier = ExecutionStrategy.MODEL_TIERS.get(
+            provider_name, ExecutionStrategy.MODEL_TIERS["triton"]
+        )
+        fast_model = model_tier.get("fast") or default_model
+
+        return ExecutionConfig(
+            mode="conversational",
+            max_iterations=1,
+            use_agent_loop=False,
+            use_planning=False,
+            model_tier="fast",
+            temperature=0.7,  # Higher for natural conversation
+            max_tokens=1000,  # Shorter responses
+            hyperparameters={
+                "model": fast_model,
+                "temperature": 0.7,
+                "max_tokens": 1000,
+            },
+        )
+
+    @staticmethod
+    def _simple_config(provider_name: str, default_model: str) -> ExecutionConfig:
+        """
+        Configuration for simple tasks.
+
+        - Agent loop with low iterations
+        - No planning phase
+        - Balanced model
+        - Medium temperature
+        """
+        model_tier = ExecutionStrategy.MODEL_TIERS.get(
+            provider_name, ExecutionStrategy.MODEL_TIERS["triton"]
+        )
+        balanced_model = model_tier.get("balanced") or default_model
+
+        return ExecutionConfig(
+            mode="agentic_simple",
+            max_iterations=5,  # Lower for simple tasks
+            use_agent_loop=True,
+            use_planning=False,  # Skip planning for simple tasks
+            model_tier="balanced",
+            temperature=0.4,  # Lower for accuracy
+            max_tokens=2000,
+            hyperparameters={
+                "model": balanced_model,
+                "temperature": 0.4,
+                "max_tokens": 2000,
+            },
+        )
+
+    @staticmethod
+    def _complex_config(provider_name: str, default_model: str) -> ExecutionConfig:
+        """
+        Configuration for complex tasks.
+
+        - Full agent loop
+        - Planning phase available
+        - Best model
+        - Low temperature for consistency
+        """
+        model_tier = ExecutionStrategy.MODEL_TIERS.get(
+            provider_name, ExecutionStrategy.MODEL_TIERS["triton"]
+        )
+        best_model = model_tier.get("best") or default_model
+
+        return ExecutionConfig(
+            mode="agentic_complex",
+            max_iterations=15,  # Full iterations
+            use_agent_loop=True,
+            use_planning=True,  # Enable planning for complex tasks
+            model_tier="best",
+            temperature=0.3,  # Lower for consistency
+            max_tokens=4000,
+            hyperparameters={
+                "model": best_model,
+                "temperature": 0.3,
+                "max_tokens": 4000,
+            },
+        )
+
+    @staticmethod
+    def get_model_for_tier(provider_name: str, tier: str, default_model: str) -> str:
+        """
+        Get model name for a specific tier.
+
+        Args:
+            provider_name: Provider name
+            tier: Model tier (fast, balanced, best)
+            default_model: Fallback model
+
+        Returns:
+            Model name
+        """
+        model_tier = ExecutionStrategy.MODEL_TIERS.get(
+            provider_name, ExecutionStrategy.MODEL_TIERS["triton"]
+        )
+        return model_tier.get(tier) or default_model