kubrick-cli 0.1.2__tar.gz

kubrick_cli-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Russell Land]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kubrick_cli-0.1.2/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: kubrick-cli
+Version: 0.1.2
+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: black>=22.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
+
+```bash
+cd /path/to/your/project
+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
+```
+
+## 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+
+- Triton Inference Server with streaming LLM model
+- Default endpoint: `http://localhost:8000`
+- Default model: `llm_decoupled`
+
+## Documentation
+
+- **[WIKI.md](docs/WIKI.md)** - Complete features, commands, and usage guide
+- **[TRITON.md](docs/TRITON.md)** - Triton backend setup and requirements
+- **[DOCKER.md](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
+```
+
+## License
+
+MIT License - See [LICENSE](LICENSE)

kubrick_cli-0.1.2/README.md

@@ -0,0 +1,64 @@
+# 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
+
+```bash
+cd /path/to/your/project
+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
+```
+
+## 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+
+- Triton Inference Server with streaming LLM model
+- Default endpoint: `http://localhost:8000`
+- Default model: `llm_decoupled`
+
+## Documentation
+
+- **[WIKI.md](docs/WIKI.md)** - Complete features, commands, and usage guide
+- **[TRITON.md](docs/TRITON.md)** - Triton backend setup and requirements
+- **[DOCKER.md](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
+```
+
+## License
+
+MIT License - See [LICENSE](LICENSE)

kubrick_cli-0.1.2/kubrick_cli/__init__.py

@@ -0,0 +1,47 @@
+"""Kubrick CLI - AI-assisted coding tool with agentic capabilities."""
+
+__version__ = "0.2.0"
+
+from .agent_loop import AgentLoop, CompletionDetector
+from .classifier import TaskClassification, TaskClassifier
+from .config import KubrickConfig
+from .display import DisplayManager
+from .execution_strategy import ExecutionConfig, ExecutionStrategy
+from .main import KubrickCLI
+from .planning import PlanningPhase
+from .progress import ProgressTracker
+from .providers.base import ProviderAdapter
+from .providers.factory import ProviderFactory
+from .providers.triton_provider import TritonProvider
+from .providers.openai_provider import OpenAIProvider
+from .providers.anthropic_provider import AnthropicProvider
+from .safety import SafetyConfig, SafetyManager
+from .scheduler import ToolScheduler
+from .setup_wizard import SetupWizard
+from .tools import ToolExecutor
+from .triton_client import TritonLLMClient
+
+__all__ = [
+    "AgentLoop",
+    "AnthropicProvider",
+    "CompletionDetector",
+    "DisplayManager",
+    "ExecutionConfig",
+    "ExecutionStrategy",
+    "KubrickCLI",
+    "KubrickConfig",
+    "OpenAIProvider",
+    "PlanningPhase",
+    "ProgressTracker",
+    "ProviderAdapter",
+    "ProviderFactory",
+    "SafetyConfig",
+    "SafetyManager",
+    "SetupWizard",
+    "TaskClassification",
+    "TaskClassifier",
+    "ToolExecutor",
+    "ToolScheduler",
+    "TritonLLMClient",
+    "TritonProvider",
+]

kubrick_cli-0.1.2/kubrick_cli/agent_loop.py

@@ -0,0 +1,307 @@
+"""Multi-step agentic execution loop with completion detection."""
+
+import re
+from typing import Dict, Iterator, List, Optional, 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:
+    ToolScheduler = None
+
+
+class CompletionDetector:
+    """Detects when an agent has completed its task."""
+
+    # Explicit completion markers the agent can use
+    COMPLETION_MARKERS = [
+        "TASK_COMPLETE",
+        "PLAN_COMPLETE",
+        "[COMPLETE]",
+        "[DONE]",
+    ]
+
+    @staticmethod
+    def is_complete(
+        response_text: str,
+        has_tool_calls: bool,
+        iteration: int,
+        max_iterations: int,
+    ) -> Tuple[bool, str]:
+        """
+        Determine if the agent has completed its task.
+
+        Args:
+            response_text: The agent's response text
+            has_tool_calls: Whether the response contains tool calls
+            iteration: Current iteration number
+            max_iterations: Maximum allowed iterations
+
+        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
+    def _looks_conclusive(text: str) -> bool:
+        """
+        Check if text looks like a conclusive response.
+
+        This is a heuristic to detect when the agent is done without
+        explicitly saying so.
+        """
+        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",
+            r"\bhere(?:'s| is) (?:the |a )?(?:summary|result)",
+            r"\b(?:task|work|changes) (?:is |are )?(?:complete|done|finished)",
+            r"\blet me know if you need",
+            r"\bthat(?:'s| should do it)",
+            r"\beverything(?:'s| is) (?:set|ready|done)",
+        ]
+
+        for pattern in conclusive_patterns:
+            if re.search(pattern, text_lower):
+                return True
+
+        return False
+
+
+class AgentLoop:
+    """
+    Multi-step agentic execution loop.
+
+    Runs iteratively until the task is complete or max iterations reached.
+    """
+
+    def __init__(
+        self,
+        llm_client,
+        tool_executor,
+        max_iterations: int = 15,
+        max_tools_per_turn: int = 5,
+        timeout_seconds: int = 600,
+        stream_options: Dict = None,
+        display_manager=None,
+        tool_scheduler=None,
+    ):
+        """
+        Initialize the agent loop.
+
+        Args:
+            llm_client: LLM client instance (e.g., TritonLLMClient)
+            tool_executor: Tool executor instance
+            max_iterations: Maximum number of iterations
+            max_tools_per_turn: Maximum tools per turn
+            timeout_seconds: Total timeout in seconds
+            stream_options: Optional streaming options
+            display_manager: Optional DisplayManager instance for natural language display
+            tool_scheduler: Optional ToolScheduler for parallel execution
+        """
+        self.llm_client = llm_client
+        self.tool_executor = tool_executor
+        self.max_iterations = max_iterations
+        self.max_tools_per_turn = max_tools_per_turn
+        self.timeout_seconds = timeout_seconds
+        self.stream_options = stream_options or {}
+        self.display_manager = display_manager
+        self.tool_scheduler = tool_scheduler
+
+    def run(
+        self,
+        messages: List[Dict],
+        tool_parser,
+        display_callback=None,
+    ) -> Dict:
+        """
+        Run the agentic loop.
+
+        Args:
+            messages: Conversation messages (will be modified in-place)
+            tool_parser: Function to parse tool calls from text
+            display_callback: Optional callback for displaying streaming response
+
+        Returns:
+            Dict with execution results and metadata
+        """
+        iteration = 0
+        total_tool_calls = 0
+
+        while iteration < self.max_iterations:
+            iteration += 1
+
+            console.print(
+                f"\n[dim]→ Agent iteration {iteration}/{self.max_iterations}[/dim]"
+            )
+
+            # Get LLM response
+            console.print("[bold cyan]Assistant:[/bold cyan]")
+            chunks = []
+
+            try:
+                for chunk in self.llm_client.generate_streaming(
+                    messages, stream_options=self.stream_options
+                ):
+                    console.print(chunk, end="")
+                    chunks.append(chunk)
+
+                console.print("\n")
+
+            except Exception as e:
+                console.print(f"\n[red]Error during LLM generation: {e}[/red]")
+                return {
+                    "success": False,
+                    "error": str(e),
+                    "iterations": iteration,
+                    "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,
+                iteration=iteration,
+                max_iterations=self.max_iterations,
+            )
+
+            if is_complete:
+                console.print(f"\n[green]✓ Task complete ({reason})[/green]")
+                return {
+                    "success": True,
+                    "completion_reason": reason,
+                    "iterations": iteration,
+                    "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)}), "
+                        f"limiting to {self.max_tools_per_turn}[/yellow]"
+                    )
+                    tool_calls = tool_calls[: self.max_tools_per_turn]
+
+                console.print(
+                    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
+                    )
+                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_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]"
+                            )
+                        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']}"
+                        )
+                    else:
+                        tool_results.append(
+                            f"Tool: {tool_name}\nError: {result['error']}"
+                        )
+
+                    total_tool_calls += 1
+
+                # Add tool results to conversation
+                tool_results_text = "\n\n".join(tool_results)
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": f"Tool execution results:\n\n{tool_results_text}",
+                    }
+                )
+
+                # 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]"
+        )
+        return {
+            "success": True,
+            "completion_reason": "max_iterations",
+            "iterations": iteration,
+            "tool_calls": total_tool_calls,
+        }