kubrick-cli 0.1.2__py3-none-any.whl

kubrick_cli/triton_client.py

@@ -0,0 +1,192 @@
+"""Triton client for streaming LLM requests using HTTP only (no dependencies)."""
+
+import http.client
+import json
+import ssl
+from typing import Dict, Iterator, List
+from urllib.parse import urlparse
+
+
+class TritonLLMClient:
+    """Client for interacting with Triton LLM backend using HTTP (no extra dependencies)."""
+
+    def __init__(
+        self,
+        url: str = "localhost:8000",
+        model_name: str = "llm_decoupled",
+    ):
+        """
+        Initialize Triton LLM client.
+
+        Args:
+            url: Triton server URL (host:port, default: localhost:8000)
+            model_name: Name of the Triton model to use
+        """
+        self.model_name = model_name
+
+        # Parse URL
+        if not url.startswith("http://") and not url.startswith("https://"):
+            url = f"http://{url}"
+
+        parsed = urlparse(url)
+        self.is_https = parsed.scheme == "https"
+        self.host = parsed.hostname or "localhost"
+        self.port = parsed.port or (443 if self.is_https else 8000)
+        self.timeout = 600
+        self.url = f"{parsed.scheme}://{self.host}:{self.port}"
+
+    def _get_connection(self) -> http.client.HTTPConnection:
+        """Create an HTTP(S) connection."""
+        if self.is_https:
+            context = ssl.create_default_context()
+            return http.client.HTTPSConnection(
+                self.host, self.port, timeout=self.timeout, context=context
+            )
+        else:
+            return http.client.HTTPConnection(
+                self.host, self.port, timeout=self.timeout
+            )
+
+    def generate_streaming(
+        self,
+        messages: List[Dict[str, str]],
+        stream_options: Dict = None,
+    ) -> Iterator[str]:
+        """
+        Generate streaming response from LLM.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            stream_options: Optional streaming parameters
+
+        Yields:
+            Text chunks as they arrive
+        """
+        # Build request payload
+        if stream_options is None:
+            stream_options = {"streaming": True}
+        else:
+            stream_options = {"streaming": True, **stream_options}
+
+        # Build the request payload using the custom generate_stream format
+        payload = {
+            "text_input": json.dumps(messages),
+            "parameters": stream_options,
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+        }
+
+        body = json.dumps(payload).encode("utf-8")
+        path = f"/v2/models/{self.model_name}/generate_stream"
+
+        conn = None
+        try:
+            conn = self._get_connection()
+            conn.request("POST", path, body=body, headers=headers)
+            response = conn.getresponse()
+
+            if response.status not in (200, 201):
+                error_body = response.read().decode("utf-8")
+                raise Exception(
+                    f"Server returned {response.status}: {error_body}"
+                )
+
+            # Read streaming response
+            buffer = ""
+            while True:
+                chunk = response.read(1024)
+                if not chunk:
+                    break
+
+                if isinstance(chunk, bytes):
+                    chunk = chunk.decode("utf-8")
+
+                buffer += chunk
+
+                # Process complete lines
+                while "\n" in buffer:
+                    line, buffer = buffer.split("\n", 1)
+                    line = line.strip()
+
+                    if not line:
+                        continue
+
+                    # Remove SSE "data: " prefix if present
+                    if line.startswith("data: "):
+                        line = line[6:]
+
+                    # Check for end signal
+                    if line == "[DONE]":
+                        return
+
+                    try:
+                        data = json.loads(line)
+
+                        # Handle both text_output and outputs formats
+                        output_data = None
+                        if "text_output" in data:
+                            output_data = data["text_output"]
+                        elif "outputs" in data and len(data["outputs"]) > 0:
+                            output_data = data["outputs"][0].get("data", [""])[
+                                0
+                            ]
+
+                        if output_data:
+                            # Parse the actual response
+                            try:
+                                chunk_data = json.loads(output_data)
+
+                                if chunk_data.get("type") == "chunk":
+                                    yield chunk_data.get("content", "")
+                                elif chunk_data.get("type") == "complete":
+                                    # Stream is complete
+                                    return
+                                elif chunk_data.get("type") == "error":
+                                    raise Exception(
+                                        f"LLM error: {chunk_data.get('content')}"
+                                    )
+                            except (json.JSONDecodeError, TypeError):
+                                # If not JSON, treat as plain text chunk
+                                yield output_data
+
+                    except json.JSONDecodeError:
+                        # If line is not JSON, skip it
+                        continue
+
+        finally:
+            if conn:
+                conn.close()
+
+    def generate(
+        self,
+        messages: List[Dict[str, str]],
+        stream_options: Dict = None,
+    ) -> str:
+        """
+        Generate non-streaming response from LLM.
+
+        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 Triton server is healthy."""
+        try:
+            conn = self._get_connection()
+            conn.request("GET", "/v2/health/live")
+            response = conn.getresponse()
+            conn.close()
+            return response.status == 200
+        except Exception:
+            return False

kubrick_cli-0.1.2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,26 @@
+kubrick_cli/__init__.py,sha256=UZSaa0ajEH_EkbP5I239WDL8cUvBaxW2wP7yz_C2VU4,1403
+kubrick_cli/agent_loop.py,sha256=DOm0URQeyALgLUWKNRSzRjxBRobOvQoB-4XAOc7slzo,10468
+kubrick_cli/classifier.py,sha256=KVstxN-PdeZz0zCpzziQpqPwaT6bj9QORabqN-Ok6qY,5359
+kubrick_cli/config.py,sha256=CZ6P6oxKjaEkAjayLlVIQlZ0xkAHdfc_bxVZlaIU-MQ,8518
+kubrick_cli/display.py,sha256=GFrrDZpFeVRIuqLJLI_mHyCuH2FbKiiBfMpQFQbBOW8,5912
+kubrick_cli/execution_strategy.py,sha256=1OK6ThFedsQgmdPGlClh5VWi_ydLile8jM1_31FAQBQ,6346
+kubrick_cli/main.py,sha256=mTDLk1WyPo1hYb3XftD54axqWKFDyCAWomrdeuotiqg,27538
+kubrick_cli/planning.py,sha256=bdWfOrfPh383FBmfLVE6QneRRLlbOzJvY1KlFfA5fbs,9222
+kubrick_cli/progress.py,sha256=D9C1Algx_aJzd_jCyBztclPRhfveUTAaidh5SGCWwCE,4764
+kubrick_cli/safety.py,sha256=01HnowDZInRIho9Y09TzrYjURl_GzLj7YVvtxH8xWvU,6510
+kubrick_cli/scheduler.py,sha256=2S6FH38atVlMnDekVgGNzKvlX1mwbJCF2DEpYmnWOt8,6043
+kubrick_cli/setup_wizard.py,sha256=yBjDey0nl-MtRF-XMZalWtcKqfoGwmfCkX7o6cpOGUQ,5129
+kubrick_cli/tools.py,sha256=5RnCK6xfV_pSaKJ-T9PklVDy_rBFoTa6nIpPr_QBxYQ,13725
+kubrick_cli/triton_client.py,sha256=XV9_s9nuNNfX840CCz0lc-7rv_-AzZXiwQg1cDg8o0I,6419
+kubrick_cli/providers/__init__.py,sha256=pI8TVid6LCEG0VMd4H-Oo-gO-40CG80gT9XZxc5Dnak,212
+kubrick_cli/providers/anthropic_provider.py,sha256=Qsmy2bHtBgxsRYbvbRWvkhK168M2xA7cxb-EBgzIxNw,6982
+kubrick_cli/providers/base.py,sha256=K7iC00pBaHuHpbIx-61u4f_Cy422XrWuHS8upkVg1tY,3847
+kubrick_cli/providers/factory.py,sha256=6pkD_cVfT5Dsiar08t3NoLJnrbP3Pggp01bJdE7Uf3A,6330
+kubrick_cli/providers/openai_provider.py,sha256=Q8ApgcmS6s0Y8a03Dx4e5QQFwXyonBNK6OLHAyoxcX8,5778
+kubrick_cli/providers/triton_provider.py,sha256=9UM76TRJAHDeYUFItvVEXmMvxex1yzJ-iRwyRhKtUDY,2735
+kubrick_cli-0.1.2.dist-info/licenses/LICENSE,sha256=Vap47V4-2uRylukx31JcYcYSD7QzURHn70rLxmFyenI,1073
+kubrick_cli-0.1.2.dist-info/METADATA,sha256=I8mz2veI5LuWX_JwSW3K8M_V7bsMrIwwkNUnUQ6tWxs,2051
+kubrick_cli-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kubrick_cli-0.1.2.dist-info/entry_points.txt,sha256=4XyhYn1bMdkgqTxwvvGe1LAtby-2lP4JaIAZUwBkP1k,50
+kubrick_cli-0.1.2.dist-info/top_level.txt,sha256=BUz1Y_kmuEM-kvPHdyv2dHO5X1dUHfmE8Mhzr0gdEkQ,12
+kubrick_cli-0.1.2.dist-info/RECORD,,

kubrick_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kubrick_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kubrick = kubrick_cli.main:main

kubrick_cli-0.1.2.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+kubrick_cli