kubrick-cli 0.1.4__py3-none-any.whl

kubrick_cli/planning.py

@@ -0,0 +1,319 @@
+"""Planning phase for complex tasks with read-only exploration."""
+
+from typing import Dict, List
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+console = Console()
+
+
+# Read-only tools allowed in planning mode
+PLANNING_ALLOWED_TOOLS = {
+    "read_file",
+    "list_files",
+    "search_files",
+    # run_bash is allowed but will be restricted to read-only commands
+}
+
+# Dangerous bash commands that are never allowed in planning
+DANGEROUS_BASH_PATTERNS = [
+    "rm ",
+    "mv ",
+    "cp ",
+    "chmod",
+    "chown",
+    "sudo",
+    "> ",
+    ">>",
+    "|",
+    "git push",
+    "git commit",
+]
+
+
+class PlanningPhase:
+    """
+    Handles the planning phase for complex tasks.
+
+    In planning mode:
+    - Agent can only use read-only tools
+    - Agent explores the codebase to understand structure
+    - Agent creates an implementation plan
+    - User approves/modifies/rejects the plan
+    - After approval, execution proceeds with full tools
+    """
+
+    def __init__(self, llm_client, tool_executor, agent_loop):
+        """
+        Initialize planning phase.
+
+        Args:
+            llm_client: LLM client instance
+            tool_executor: Tool executor instance
+            agent_loop: Agent loop instance for execution
+        """
+        self.llm_client = llm_client
+        self.tool_executor = tool_executor
+        self.agent_loop = agent_loop
+
+    def execute_planning(self, user_message: str, base_messages: List[Dict]) -> str:
+        """
+        Execute the planning phase.
+
+        Args:
+            user_message: The user's original request
+            base_messages: Base conversation messages
+
+        Returns:
+            The generated plan text
+        """
+        console.print("\n[bold yellow]→ Entering PLANNING MODE[/bold yellow]")
+        console.print(
+            "[dim]Agent will explore the codebase with read-only tools and create a plan.[/dim]\n"
+        )
+
+        planning_messages = base_messages.copy()
+
+        planning_messages.append(
+            {
+                "role": "system",
+                "content": """# PLANNING MODE
+
+You are now in PLANNING MODE. Your task is to:
+1. EXPLORE the codebase using read-only tools
+2. DESIGN an implementation approach
+3. CREATE a detailed plan
+
+# Available Tools (READ-ONLY)
+
+You can ONLY use these tools:
+- read_file: Read file contents
+- list_files: List files matching patterns (supports recursive patterns like "**/*.py")
+- search_files: Search for text in files
+- run_bash: Run ONLY read-only commands (ls, find, cat, grep, tree, etc.)
+
+You CANNOT use:
+- write_file
+- edit_file
+- create_directory
+- Any destructive bash commands
+
+# How to Explore the Codebase
+
+**IMPORTANT**: To get a complete understanding, you MUST explore systematically:
+
+1. **Start with directory structure**:
+   - Use `list_files` with pattern `**/*` to see ALL files and directories recursively
+   - Or use `run_bash` with command `find . -type f` to list all files
+   - Or use `run_bash` with command `tree` or `ls -R` to see the full structure
+
+2. **List files by type**:
+   - Python: `list_files` with pattern `**/*.py`
+   - JavaScript: `list_files` with pattern `**/*.js`
+   - All code files: Try multiple patterns to cover all file types
+
+3. **Read key files**:
+   - README files
+   - Configuration files (package.json, requirements.txt, pyproject.toml, etc.)
+   - Main entry points
+   - Important modules based on the task
+
+4. **Search for specific patterns**:
+   - Use `search_files` to find classes, functions, imports, etc.
+
+**Example exploration workflow**:
+```tool_call
+{
+  "tool": "list_files",
+  "parameters": {
+    "pattern": "**/*"
+  }
+}
+```
+
+Then read relevant files:
+```tool_call
+{
+  "tool": "read_file",
+  "parameters": {
+    "file_path": "path/to/important/file.py"
+  }
+}
+```
+
+# Plan Format
+
+When ready, create a plan in this format:
+
+## Implementation Plan
+
+### Overview
+[Brief description of what you'll do]
+
+### Steps
+1. [First step]
+2. [Second step]
+3. [etc.]
+
+### Files to Modify
+- file1.py: [what changes]
+- file2.py: [what changes]
+
+### Risks
+- [Potential issues or concerns]
+
+# Completion
+
+Say "PLAN_COMPLETE" when your plan is ready.""",
+            }
+        )
+
+        planning_messages.append(
+            {
+                "role": "user",
+                "content": (
+                    f"Task: {user_message}\n\n"
+                    "Please explore the codebase and create an implementation plan."
+                ),
+            }
+        )
+
+        original_executor = self.agent_loop.tool_executor
+        restricted_executor = RestrictedToolExecutor(
+            self.tool_executor, PLANNING_ALLOWED_TOOLS
+        )
+        self.agent_loop.tool_executor = restricted_executor
+
+        try:
+            old_max = self.agent_loop.max_iterations
+            self.agent_loop.max_iterations = 10
+
+            from .main import KubrickCLI
+
+            temp_cli = KubrickCLI.__new__(KubrickCLI)
+            tool_parser = temp_cli.parse_tool_calls
+
+            self.agent_loop.run(
+                messages=planning_messages,
+                tool_parser=tool_parser,
+                display_callback=None,
+            )
+
+            self.agent_loop.max_iterations = old_max
+
+            plan_text = ""
+            for msg in reversed(planning_messages):
+                if msg["role"] == "assistant":
+                    plan_text = msg["content"]
+                    break
+
+            return plan_text
+
+        finally:
+            self.agent_loop.tool_executor = original_executor
+
+    def get_user_approval(self, plan: str) -> Dict:
+        """
+        Present plan to user and get approval.
+
+        Args:
+            plan: The generated plan text
+
+        Returns:
+            Dict with 'approved' (bool) and optional 'modifications' (str)
+        """
+        console.print("\n" + "=" * 70)
+        console.print(
+            Panel(
+                Markdown(plan),
+                title="[bold cyan]Implementation Plan[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+        console.print("=" * 70 + "\n")
+
+        choice = Prompt.ask(
+            "[bold yellow]Approve this plan?[/bold yellow]",
+            choices=["approve", "modify", "reject"],
+            default="approve",
+        )
+
+        if choice == "approve":
+            console.print(
+                "[green]✓ Plan approved, proceeding with implementation[/green]"
+            )
+            return {"approved": True}
+
+        elif choice == "modify":
+            modifications = Prompt.ask(
+                "[yellow]What modifications would you like?[/yellow]"
+            )
+            console.print("[yellow]Plan modifications noted, will adjust[/yellow]")
+            return {"approved": True, "modifications": modifications}
+
+        else:
+            console.print("[red]Plan rejected, cancelling task[/red]")
+            return {"approved": False}
+
+
+class RestrictedToolExecutor:
+    """
+    Wraps ToolExecutor to restrict to read-only tools during planning.
+    """
+
+    def __init__(self, base_executor, allowed_tools: set):
+        """
+        Initialize restricted executor.
+
+        Args:
+            base_executor: Base ToolExecutor instance
+            allowed_tools: Set of allowed tool names
+        """
+        self.base_executor = base_executor
+        self.allowed_tools = allowed_tools
+
+    def execute(self, tool_name: str, parameters: Dict) -> Dict:
+        """
+        Execute tool with restrictions.
+
+        Args:
+            tool_name: Name of tool to execute
+            parameters: Tool parameters
+
+        Returns:
+            Result dict
+        """
+        if tool_name not in self.allowed_tools:
+            return {
+                "success": False,
+                "error": f"Tool '{tool_name}' is not allowed in planning mode (read-only)",
+            }
+
+        if tool_name == "run_bash":
+            command = parameters.get("command", "")
+            if self._is_dangerous_command(command):
+                return {
+                    "success": False,
+                    "error": (
+                        f"Bash command '{command}' is not allowed in "
+                        "planning mode (read-only)"
+                    ),
+                }
+
+        return self.base_executor.execute(tool_name, parameters)
+
+    def _is_dangerous_command(self, command: str) -> bool:
+        """Check if bash command is dangerous."""
+        command_lower = command.lower()
+        for pattern in DANGEROUS_BASH_PATTERNS:
+            if pattern in command_lower:
+                return True
+        return False
+
+    @property
+    def working_dir(self):
+        """Pass through working_dir property."""
+        return self.base_executor.working_dir

kubrick_cli/progress.py

@@ -0,0 +1,162 @@
+"""Progress tracking and visualization for multi-step tasks."""
+
+from typing import Optional
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TimeElapsedColumn,
+)
+
+console = Console()
+
+
+class ProgressTracker:
+    """
+    Tracks and displays progress for multi-step agentic tasks.
+
+    Provides visual feedback during long-running operations.
+    """
+
+    def __init__(self, enabled: bool = True):
+        """
+        Initialize progress tracker.
+
+        Args:
+            enabled: Whether progress tracking is enabled
+        """
+        self.enabled = enabled
+        self.progress: Optional[Progress] = None
+        self.current_task: Optional[TaskID] = None
+        self.step_count = 0
+        self.total_steps = 0
+
+    def start(self, total_steps: int = None, description: str = "Working"):
+        """
+        Start progress tracking.
+
+        Args:
+            total_steps: Total number of steps (if known)
+            description: Initial description
+        """
+        if not self.enabled:
+            return
+
+        self.total_steps = total_steps or 0
+        self.step_count = 0
+
+        if total_steps:
+            self.progress = Progress(
+                SpinnerColumn(),
+                TextColumn("[bold cyan]{task.description}"),
+                BarColumn(),
+                TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                TimeElapsedColumn(),
+                console=console,
+            )
+        else:
+            self.progress = Progress(
+                SpinnerColumn(),
+                TextColumn("[bold cyan]{task.description}"),
+                TimeElapsedColumn(),
+                console=console,
+            )
+
+        self.progress.start()
+        self.current_task = self.progress.add_task(description, total=total_steps)
+
+    def update(self, description: str = None, advance: int = 1, completed: int = None):
+        """
+        Update progress.
+
+        Args:
+            description: New description (optional)
+            advance: Amount to advance (default: 1)
+            completed: Set absolute completion (optional)
+        """
+        if not self.enabled or not self.progress:
+            return
+
+        if completed is not None:
+            self.step_count = completed
+            self.progress.update(self.current_task, completed=completed)
+        else:
+            self.step_count += advance
+            self.progress.update(self.current_task, advance=advance)
+
+        if description:
+            self.progress.update(self.current_task, description=description)
+
+    def update_description(self, description: str):
+        """
+        Update just the description.
+
+        Args:
+            description: New description
+        """
+        if not self.enabled or not self.progress:
+            return
+
+        self.progress.update(self.current_task, description=description)
+
+    def step(self, description: str):
+        """
+        Mark a step complete with new description.
+
+        Args:
+            description: Description of the new step
+        """
+        if not self.enabled or not self.progress:
+            console.print(f"[dim]→ {description}[/dim]")
+            return
+
+        self.step_count += 1
+        step_info = ""
+        if self.total_steps > 0:
+            step_info = f"[Step {self.step_count}/{self.total_steps}] "
+
+        self.progress.update(
+            self.current_task,
+            description=f"{step_info}{description}",
+            advance=1,
+        )
+
+    def complete(self, message: str = "Complete"):
+        """
+        Mark progress as complete.
+
+        Args:
+            message: Completion message
+        """
+        if not self.enabled or not self.progress:
+            return
+
+        if self.total_steps:
+            self.progress.update(self.current_task, completed=self.total_steps)
+
+        self.progress.update(self.current_task, description=message)
+        self.progress.stop()
+        self.progress = None
+        self.current_task = None
+
+    def stop(self):
+        """Stop progress tracking."""
+        if not self.enabled or not self.progress:
+            return
+
+        self.progress.stop()
+        self.progress = None
+        self.current_task = None
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        if self.progress:
+            self.stop()

kubrick_cli/providers/__init__.py

@@ -0,0 +1,6 @@
+"""Provider adapters for different LLM backends."""
+
+from .base import ProviderAdapter, ProviderMetadata
+from .factory import ProviderFactory
+
+__all__ = ["ProviderAdapter", "ProviderMetadata", "ProviderFactory"]

kubrick_cli/providers/anthropic_provider.py

@@ -0,0 +1,209 @@
+"""Anthropic provider adapter."""
+
+import http.client
+import json
+import ssl
+from typing import Dict, Iterator, List
+
+from .base import ProviderAdapter, ProviderMetadata
+
+
+class AnthropicProvider(ProviderAdapter):
+    """Provider adapter for Anthropic API."""
+
+    METADATA = ProviderMetadata(
+        name="anthropic",
+        display_name="Anthropic",
+        description="Anthropic API (Claude Sonnet 4.5, etc.)",
+        config_fields=[
+            {
+                "key": "anthropic_api_key",
+                "label": "Anthropic API key",
+                "type": "password",
+                "help_text": "Get your API key from: https://console.anthropic.com/settings/keys",
+            },
+            {
+                "key": "anthropic_model",
+                "label": "Model name",
+                "type": "text",
+                "default": "claude-sonnet-4-5-20250929",
+            },
+        ],
+    )
+
+    def __init__(
+        self,
+        anthropic_api_key: str,
+        anthropic_model: str = "claude-sonnet-4-5-20250929",
+    ):
+        """
+        Initialize Anthropic provider.
+
+        Args:
+            anthropic_api_key: Anthropic API key
+            anthropic_model: Model name (default: claude-3-5-sonnet-20241022)
+        """
+        self.api_key = anthropic_api_key
+        self._model_name = anthropic_model
+        self.base_url = "api.anthropic.com"
+        self.timeout = 600
+        self.api_version = "2023-06-01"
+
+    def generate_streaming(
+        self, messages: List[Dict[str, str]], stream_options: Dict = None
+    ) -> Iterator[str]:
+        """
+        Generate streaming response from Anthropic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            stream_options: Optional streaming parameters
+
+        Yields:
+            Text chunks as they arrive
+        """
+        system_message = ""
+        conversation_messages = []
+
+        for msg in messages:
+            if msg["role"] == "system":
+                system_message = msg["content"]
+            else:
+                conversation_messages.append(msg)
+
+        payload = {
+            "model": self._model_name,
+            "messages": conversation_messages,
+            "max_tokens": 4096,
+            "stream": True,
+        }
+
+        if system_message:
+            payload["system"] = system_message
+
+        if stream_options:
+            if "temperature" in stream_options:
+                payload["temperature"] = stream_options["temperature"]
+            if "max_tokens" in stream_options:
+                payload["max_tokens"] = stream_options["max_tokens"]
+
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": self.api_key,
+            "anthropic-version": self.api_version,
+        }
+
+        body = json.dumps(payload).encode("utf-8")
+
+        context = ssl.create_default_context()
+        conn = http.client.HTTPSConnection(
+            self.base_url, 443, timeout=self.timeout, context=context
+        )
+
+        try:
+            conn.request("POST", "/v1/messages", body=body, headers=headers)
+            response = conn.getresponse()
+
+            if response.status != 200:
+                error_body = response.read().decode("utf-8")
+                raise Exception(f"Anthropic API error {response.status}: {error_body}")
+
+            buffer = ""
+            while True:
+                chunk = response.read(1024)
+                if not chunk:
+                    break
+
+                if isinstance(chunk, bytes):
+                    chunk = chunk.decode("utf-8")
+
+                buffer += chunk
+
+                while "\n" in buffer:
+                    line, buffer = buffer.split("\n", 1)
+                    line = line.strip()
+
+                    if not line:
+                        continue
+
+                    if line.startswith("data: "):
+                        line = line[6:]
+
+                    if line.startswith("event: "):
+                        continue
+
+                    try:
+                        data = json.loads(line)
+
+                        event_type = data.get("type")
+
+                        if event_type == "content_block_delta":
+                            delta = data.get("delta", {})
+                            if delta.get("type") == "text_delta":
+                                text = delta.get("text", "")
+                                if text:
+                                    yield text
+
+                        elif event_type == "message_stop":
+                            return
+
+                    except json.JSONDecodeError:
+                        continue
+
+        finally:
+            conn.close()
+
+    def generate(
+        self, messages: List[Dict[str, str]], stream_options: Dict = None
+    ) -> str:
+        """
+        Generate non-streaming response from Anthropic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            stream_options: Optional parameters
+
+        Returns:
+            Complete response text
+        """
+        chunks = []
+        for chunk in self.generate_streaming(messages, stream_options):
+            chunks.append(chunk)
+        return "".join(chunks)
+
+    def is_healthy(self) -> bool:
+        """
+        Check if Anthropic API is accessible.
+
+        Returns:
+            True if healthy, False otherwise
+        """
+        try:
+            context = ssl.create_default_context()
+            conn = http.client.HTTPSConnection(
+                self.base_url, 443, timeout=10, context=context
+            )
+            headers = {
+                "x-api-key": self.api_key,
+                "anthropic-version": self.api_version,
+            }
+            conn.request("GET", "/v1/models", headers=headers)
+            response = conn.getresponse()
+            conn.close()
+            return response.status in (200, 404)
+        except Exception:
+            return False
+
+    @property
+    def provider_name(self) -> str:
+        """Get provider name."""
+        return "anthropic"
+
+    @property
+    def model_name(self) -> str:
+        """Get model name."""
+        return self._model_name
+
+    def set_model(self, model_name: str):
+        """Set model name dynamically."""
+        self._model_name = model_name