kubrick-cli 0.1.2__tar.gz → 0.1.4__tar.gz

kubrick_cli-0.1.4/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: kubrick-cli
+Version: 0.1.4
+Summary: A CLI tool for AI-assisted coding using Triton LLM backend
+Author-email: Russell Land <rcland12@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rcland12/kubrick-cli
+Project-URL: Repository, https://github.com/rcland12/kubrick-cli
+Project-URL: Issues, https://github.com/rcland12/kubrick-cli/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: prompt_toolkit>=3.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# Kubrick CLI
+
+An AI-assisted coding CLI tool powered by your own Triton LLM backend. Like Claude Code, but self-hosted.
+
+## Installation
+
+### Local Installation
+
+```bash
+pip install -e .
+kubrick
+```
+
+### Docker
+
+Available from Docker Hub or GitHub Container Registry:
+
+```bash
+cd /path/to/your/project
+
+# From Docker Hub
+docker run --rm -it \
+  --network host \
+  -v ${HOME}:/home/kubrick \
+  -v ${PWD}:/workspace \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v /etc/timezone:/etc/timezone:ro \
+  rcland12/kubrick-cli
+
+# From GitHub Container Registry
+docker run --rm -it \
+  --network host \
+  -v ${HOME}:/home/kubrick \
+  -v ${PWD}:/workspace \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v /etc/timezone:/etc/timezone:ro \
+  ghcr.io/rcland12/kubrick-cli
+```
+
+## Quick Start
+
+```bash
+# Basic usage
+kubrick
+
+# Custom Triton server
+kubrick --triton-url my-server:8000
+
+# Load previous conversation
+kubrick --load 20240118_143022
+```
+
+## Requirements
+
+- Python 3.8+
+- LLM Provider (choose one):
+  - **Triton Inference Server** with streaming LLM model (default: `http://localhost:8000`)
+  - **OpenAI API** (GPT-4, GPT-3.5-turbo, etc.)
+  - **Anthropic API** (Claude models)
+
+## Documentation
+
+- **[WIKI.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/WIKI.md)** - Complete features, commands, and usage guide
+- **[PROVIDERS.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/PROVIDERS.md)** - Multi-provider setup (Triton, OpenAI, Anthropic)
+- **[TRITON.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/TRITON.md)** - Triton backend setup and requirements
+- **[TESTING.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/TESTING.md)** - Testing guide and CI/CD setup
+- **[DOCKER.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/DOCKER.md)** - Docker setup and troubleshooting
+
+## Configuration
+
+Config stored at `~/.kubrick/config.json`. Override with environment variables:
+
+```bash
+export TRITON_URL=localhost:8000
+export TRITON_MODEL_NAME=llm_decoupled
+```
+
+## Development
+
+### Install Development Dependencies
+
+```bash
+pip install -e ".[dev]"
+```
+
+### Run Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=kubrick_cli --cov-report=term-missing
+
+# Run specific test file
+pytest tests/test_tool_executor.py -v
+```
+
+See [TESTING.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/TESTING.md) for detailed testing documentation.
+
+### Code Quality
+
+```bash
+# Format code
+black kubrick_cli tests
+
+# Check linting
+flake8 kubrick_cli
+```
+
+## License
+
+MIT License - See [LICENSE](LICENSE)

kubrick_cli-0.1.4/README.md

@@ -0,0 +1,113 @@
+# Kubrick CLI
+
+An AI-assisted coding CLI tool powered by your own Triton LLM backend. Like Claude Code, but self-hosted.
+
+## Installation
+
+### Local Installation
+
+```bash
+pip install -e .
+kubrick
+```
+
+### Docker
+
+Available from Docker Hub or GitHub Container Registry:
+
+```bash
+cd /path/to/your/project
+
+# From Docker Hub
+docker run --rm -it \
+  --network host \
+  -v ${HOME}:/home/kubrick \
+  -v ${PWD}:/workspace \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v /etc/timezone:/etc/timezone:ro \
+  rcland12/kubrick-cli
+
+# From GitHub Container Registry
+docker run --rm -it \
+  --network host \
+  -v ${HOME}:/home/kubrick \
+  -v ${PWD}:/workspace \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v /etc/timezone:/etc/timezone:ro \
+  ghcr.io/rcland12/kubrick-cli
+```
+
+## Quick Start
+
+```bash
+# Basic usage
+kubrick
+
+# Custom Triton server
+kubrick --triton-url my-server:8000
+
+# Load previous conversation
+kubrick --load 20240118_143022
+```
+
+## Requirements
+
+- Python 3.8+
+- LLM Provider (choose one):
+  - **Triton Inference Server** with streaming LLM model (default: `http://localhost:8000`)
+  - **OpenAI API** (GPT-4, GPT-3.5-turbo, etc.)
+  - **Anthropic API** (Claude models)
+
+## Documentation
+
+- **[WIKI.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/WIKI.md)** - Complete features, commands, and usage guide
+- **[PROVIDERS.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/PROVIDERS.md)** - Multi-provider setup (Triton, OpenAI, Anthropic)
+- **[TRITON.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/TRITON.md)** - Triton backend setup and requirements
+- **[TESTING.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/TESTING.md)** - Testing guide and CI/CD setup
+- **[DOCKER.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/DOCKER.md)** - Docker setup and troubleshooting
+
+## Configuration
+
+Config stored at `~/.kubrick/config.json`. Override with environment variables:
+
+```bash
+export TRITON_URL=localhost:8000
+export TRITON_MODEL_NAME=llm_decoupled
+```
+
+## Development
+
+### Install Development Dependencies
+
+```bash
+pip install -e ".[dev]"
+```
+
+### Run Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=kubrick_cli --cov-report=term-missing
+
+# Run specific test file
+pytest tests/test_tool_executor.py -v
+```
+
+See [TESTING.md](https://github.com/rcland12/kubrick-cli/blob/master/docs/TESTING.md) for detailed testing documentation.
+
+### Code Quality
+
+```bash
+# Format code
+black kubrick_cli tests
+
+# Check linting
+flake8 kubrick_cli
+```
+
+## License
+
+MIT License - See [LICENSE](LICENSE)

{kubrick_cli-0.1.2 → kubrick_cli-0.1.4}/kubrick_cli/agent_loop.py

@@ -1,19 +1,17 @@
 """Multi-step agentic execution loop with completion detection."""
 
 import re
-from typing import Dict, Iterator, List, Optional, Tuple
+from typing import Dict, List, Tuple
 
 from rich.console import Console
 
 console = Console()
 
-# Import display manager (will be None if not available)
 try:
     from .display import DisplayManager
 except ImportError:
     DisplayManager = None
 
-# Import scheduler (will be None if not available)
 try:
     from .scheduler import ToolScheduler
 except ImportError:
@@ -23,7 +21,6 @@ except ImportError:
 class CompletionDetector:
     """Detects when an agent has completed its task."""
 
-    # Explicit completion markers the agent can use
     COMPLETION_MARKERS = [
         "TASK_COMPLETE",
         "PLAN_COMPLETE",
@@ -50,22 +47,17 @@ class CompletionDetector:
         Returns:
             Tuple of (is_complete, reason)
         """
-        # Check for explicit completion markers
         for marker in CompletionDetector.COMPLETION_MARKERS:
             if marker in response_text:
                 return True, f"explicit_marker:{marker}"
 
-        # Max iterations reached (fallback safety)
         if iteration >= max_iterations:
             return True, "max_iterations_reached"
 
-        # If no tool calls and response looks conclusive
         if not has_tool_calls:
-            # Check if response appears to be a final summary/conclusion
             if CompletionDetector._looks_conclusive(response_text):
                 return True, "conclusive_response"
 
-        # Otherwise, continue
         return False, "continuing"
 
     @staticmethod
@@ -78,7 +70,6 @@ class CompletionDetector:
         """
         text_lower = text.lower()
 
-        # Look for summary/conclusion indicators
         conclusive_patterns = [
             r"\b(done|completed|finished|ready)\b",
             r"\b(successfully|all set|good to go)\b",
@@ -163,7 +154,6 @@ class AgentLoop:
                 f"\n[dim]→ Agent iteration {iteration}/{self.max_iterations}[/dim]"
             )
 
-            # Get LLM response
             console.print("[bold cyan]Assistant:[/bold cyan]")
             chunks = []
 
@@ -185,20 +175,15 @@ class AgentLoop:
                     "tool_calls": total_tool_calls,
                 }
 
-            # Get full response
             response_text = "".join(chunks)
 
-            # Add to conversation
             messages.append({"role": "assistant", "content": response_text})
 
-            # Display with custom callback if provided
             if display_callback:
                 display_callback(response_text)
 
-            # Parse tool calls
             tool_calls = tool_parser(response_text)
 
-            # Check completion
             is_complete, reason = CompletionDetector.is_complete(
                 response_text=response_text,
                 has_tool_calls=len(tool_calls) > 0,
@@ -215,9 +200,7 @@ class AgentLoop:
                     "tool_calls": total_tool_calls,
                 }
 
-            # Execute tool calls if any
             if tool_calls:
-                # Enforce max tools per turn
                 if len(tool_calls) > self.max_tools_per_turn:
                     console.print(
                         f"[yellow]⚠ Too many tool calls ({len(tool_calls)}), "
@@ -229,44 +212,32 @@ class AgentLoop:
                     f"\n[yellow]Executing {len(tool_calls)} tool(s)...[/yellow]\n"
                 )
 
-                # Execute tools (with or without scheduler)
                 if self.tool_scheduler and len(tool_calls) > 1:
-                    # Use scheduler for parallel execution
-                    execution_results = self.tool_scheduler.execute_tools(
-                        tool_calls
-                    )
+                    execution_results = self.tool_scheduler.execute_tools(tool_calls)
                 else:
-                    # Execute sequentially
                     execution_results = [
                         self.tool_executor.execute(tool_name, params)
                         for tool_name, params in tool_calls
                     ]
 
-                # Display and collect results
                 tool_results = []
                 for (tool_name, parameters), result in zip(
                     tool_calls, execution_results
                 ):
-                    # Display tool call and result
                     if self.display_manager:
-                        self.display_manager.display_tool_call(
-                            tool_name, parameters
-                        )
+                        self.display_manager.display_tool_call(tool_name, parameters)
                         self.display_manager.display_tool_result(
                             tool_name, result, result["success"]
                         )
                     else:
                         console.print(f"[cyan]→ Called {tool_name}[/cyan]")
                         if result["success"]:
-                            console.print(
-                                f"[green]✓ {tool_name} succeeded[/green]"
-                            )
+                            console.print(f"[green]✓ {tool_name} succeeded[/green]")
                         else:
                             console.print(
                                 f"[red]✗ {tool_name} failed: {result['error']}[/red]"
                             )
 
-                    # Add to results
                     if result["success"]:
                         tool_results.append(
                             f"Tool: {tool_name}\nResult: {result['result']}"
@@ -278,7 +249,6 @@ class AgentLoop:
 
                     total_tool_calls += 1
 
-                # Add tool results to conversation
                 tool_results_text = "\n\n".join(tool_results)
                 messages.append(
                     {
@@ -287,15 +257,12 @@ class AgentLoop:
                     }
                 )
 
-                # Continue to next iteration
                 continue
 
-            # If no tool calls and not complete, something might be wrong
             console.print(
                 "[yellow]⚠ No tool calls and task not marked complete. Continuing...[/yellow]"
             )
 
-        # Max iterations reached
         console.print(
             f"\n[yellow]⚠ Max iterations ({self.max_iterations}) reached[/yellow]"
         )

{kubrick_cli-0.1.2 → kubrick_cli-0.1.4}/kubrick_cli/classifier.py

@@ -64,7 +64,6 @@ class TaskClassifier:
         Returns:
             TaskClassification object with detailed classification
         """
-        # Build classification prompt
         classification_messages = [
             {
                 "role": "system",
@@ -146,12 +145,10 @@ Respond with ONLY the JSON object, no other text.""",
         ]
 
         try:
-            # Get classification from LLM (non-streaming for speed)
             response = self.llm_client.generate(
                 classification_messages, stream_options={}
             )
 
-            # Parse JSON response
             json_start = response.find("{")
             json_end = response.rfind("}") + 1
 
@@ -175,7 +172,6 @@ Respond with ONLY the JSON object, no other text.""",
                     requires_tools=requires_tools,
                 )
 
-            # Fallback: default to SIMPLE if parsing fails
             console.print(
                 "[yellow]⚠ Classification parsing failed, defaulting to SIMPLE[/yellow]"
             )

{kubrick_cli-0.1.2 → kubrick_cli-0.1.4}/kubrick_cli/config.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """Configuration management for Kubrick CLI."""
 
 import json
@@ -23,10 +22,8 @@ class KubrickConfig:
         self.config_file = self.kubrick_dir / "config.json"
         self.conversations_dir = self.kubrick_dir / "conversations"
 
-        # Ensure directories exist
         self._ensure_directories()
 
-        # Load or create config (with optional setup wizard)
         self.config = self._load_config(skip_wizard=skip_wizard)
 
     def _ensure_directories(self):
@@ -49,29 +46,24 @@ class KubrickConfig:
                 with open(self.config_file, "r") as f:
                     loaded_config = json.load(f)
 
-                # Merge with defaults to ensure all keys exist
                 default_config = self._get_default_config()
                 default_config.update(loaded_config)
                 return default_config
 
             except (json.JSONDecodeError, IOError):
-                # If config is corrupted, start fresh
                 return self._get_default_config()
         else:
-            # First time setup - run wizard unless skipped
             if not skip_wizard:
                 from .setup_wizard import SetupWizard
 
                 wizard_config = SetupWizard.run()
 
-                # Merge wizard config with defaults
                 config = self._get_default_config()
                 config.update(wizard_config)
 
                 self._save_config(config)
                 return config
             else:
-                # Create default config without wizard
                 config = self._get_default_config()
                 self._save_config(config)
                 return config
@@ -105,7 +97,7 @@ class KubrickConfig:
             "tool_timeout_seconds": 30,
             "max_file_size_mb": 10,
             # Display settings
-            "display_mode": "natural",  # natural, json, verbose
+            "display_mode": "natural",
             "show_tool_results": True,
             "show_progress": True,
             # Task classification settings
@@ -156,20 +148,30 @@ class KubrickConfig:
         with open(conversation_file, "w") as f:
             json.dump(data, f, indent=2)
 
-        # Clean up old conversations if we exceed max
         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: Unique identifier for the conversation
+            conversation_id: Conversation ID or file path
 
         Returns:
             Dictionary with 'id', 'messages', and 'metadata', or None if not found
         """
-        conversation_file = self.conversations_dir / f"{conversation_id}.json"
+        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
@@ -208,7 +210,6 @@ class KubrickConfig:
             except (json.JSONDecodeError, IOError):
                 continue
 
-        # Sort by modification time (newest first)
         conversations.sort(key=lambda x: x["modified"], reverse=True)
 
         if limit:
@@ -240,9 +241,7 @@ class KubrickConfig:
         conversations = list(self.conversations_dir.glob("*.json"))
 
         if len(conversations) > max_conversations:
-            # Sort by modification time (oldest first)
             conversations.sort(key=lambda x: x.stat().st_mtime)
 
-            # Delete oldest conversations
             for conv_file in conversations[: len(conversations) - max_conversations]:
                 conv_file.unlink()

{kubrick_cli-0.1.2 → kubrick_cli-0.1.4}/kubrick_cli/display.py

@@ -65,16 +65,12 @@ class DisplayManager:
         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]
-    ):
+    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]
-    ):
+    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)
@@ -86,15 +82,12 @@ class DisplayManager:
     ):
         """Display result in natural language."""
         if success:
-            # Extract key information from result
             result_text = result.get("result", "")
 
-            # Truncate long results for display
             if len(result_text) > 200:
                 preview = result_text[:200] + "..."
-                console.print(
-                    f"[green]✓ {tool_name} succeeded[/green] [dim](output truncated)[/dim]"
-                )
+                console.print(f"[green]✓ {tool_name} succeeded[/green]")
+                console.print(f"[dim]{preview}[/dim]")
             else:
                 console.print(f"[green]✓ {tool_name} succeeded[/green]")
         else:
@@ -131,9 +124,7 @@ class DisplayManager:
         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}"
-            )
+            return f"Writing {content_length} characters to {file_path}"
 
         elif tool_name == "edit_file":
             file_path = parameters.get("file_path", "unknown")
@@ -151,7 +142,6 @@ class DisplayManager:
 
         elif tool_name == "run_bash":
             command = parameters.get("command", "")
-            # Truncate long commands
             if len(command) > 60:
                 command = command[:60] + "..."
             return f"Running bash command: {command}"
@@ -161,5 +151,4 @@ class DisplayManager:
             return f"Creating directory {path}"
 
         else:
-            # Fallback for unknown tools
             return f"Calling {tool_name}"

{kubrick_cli-0.1.2 → kubrick_cli-0.1.4}/kubrick_cli/execution_strategy.py

@@ -30,7 +30,6 @@ class ExecutionStrategy:
     - Quality (best models for complex tasks)
     """
 
-    # Model tiers by provider
     MODEL_TIERS = {
         "openai": {
             "fast": "gpt-3.5-turbo",
@@ -38,13 +37,12 @@ class ExecutionStrategy:
             "best": "gpt-4",
         },
         "anthropic": {
-            "fast": "claude-haiku-4-5-20251001",  # 4-5x faster, 1/3 cost
-            "balanced": "claude-sonnet-4-5-20250929",  # Claude Sonnet 4.5 (best balance, workhorse)
-            "best": "claude-opus-4-1-20250805",  # Claude Opus 4.1 (most capable)
+            "fast": "claude-haiku-4-5-20251001",
+            "balanced": "claude-sonnet-4-5-20250929",
+            "best": "claude-opus-4-1-20250805",
         },
         "triton": {
-            # Triton uses same model for all tiers
-            "fast": None,  # Use configured model
+            "fast": None,
             "balanced": None,
             "best": None,
         },