cobalt-cli-linux 0.1.6__tar.gz → 0.1.7__tar.gz

{cobalt_cli_linux-0.1.6 → cobalt_cli_linux-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobalt-cli-linux
-Version: 0.1.6
+Version: 0.1.7
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT

{cobalt_cli_linux-0.1.6 → cobalt_cli_linux-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cobalt-cli-linux"
-version = "0.1.6"
+version = "0.1.7"
 description = "Agentic Groq-powered CLI assistant for Debian Linux"
 readme = "README.md"
 requires-python = ">=3.10"

{cobalt_cli_linux-0.1.6 → cobalt_cli_linux-0.1.7}/src/cobalt_cli_linux/groq_client.py

@@ -16,6 +16,7 @@ class GroqStreamEvent(dict[str, str]):
 
 
 class GroqClient:
+    MAX_MODEL_TOKENS = 512
     DEFAULT_MODELS: ClassVar[list[str]] = [
         "llama-3.3-70b-versatile",
         "llama-3.1-8b-instant",
@@ -46,6 +47,9 @@ class GroqClient:
         lowered = model_id.lower()
         return not any(token in lowered for token in self.NON_CHAT_TOKENS)
 
+    def _safe_max_tokens(self, max_tokens: int) -> int:
+        return max(1, min(max_tokens, self.MAX_MODEL_TOKENS))
+
     def resolve_model(self) -> str:
         if self.model and self.model != "auto":
             return self.model
@@ -85,7 +89,7 @@ class GroqClient:
             "model": resolved_model,
             "messages": messages,
             "temperature": temperature,
-            "max_tokens": max_tokens,
+            "max_tokens": self._safe_max_tokens(max_tokens),
         }
         headers = {
             "Authorization": f"Bearer {self.api_key}",
@@ -135,7 +139,7 @@ class GroqClient:
             "model": resolved_model,
             "messages": messages,
             "temperature": temperature,
-            "max_tokens": max_tokens,
+            "max_tokens": self._safe_max_tokens(max_tokens),
             "stream": True,
         }
         headers = {

{cobalt_cli_linux-0.1.6 → cobalt_cli_linux-0.1.7}/src/cobalt_cli_linux/tui.py

@@ -32,6 +32,7 @@ class CobaltTUI:
         self.auth_view: str | None = None
         self.auth_field = 0
         self.auth_values = ["", ""]
+        self.scroll_offset = 0
 
     def _load_ascii_art(self) -> list[str]:
         ascii_path = Path(__file__).resolve().parents[2] / "ASCII.txt"
@@ -93,6 +94,7 @@ class CobaltTUI:
         self.history = self.current_chat
         self.selected_chat_path = str(self.current_chat.path)
         self.chat_files = self.chat_store.list_chats()
+        self.scroll_offset = 0
 
     def _delete_selected_chat(self) -> None:
         if not self.selected_chat_path:
@@ -106,6 +108,7 @@ class CobaltTUI:
             self.selected_chat_path = str(self.chat_files[-1])
             self.history = self.chat_store.load_chat(self.selected_chat_path)
             self.current_chat = self.history
+            self.scroll_offset = 0
         else:
             self._start_new_chat()
 
@@ -171,6 +174,9 @@ class CobaltTUI:
             stdscr.addstr(box_y + 1 + index, box_x, f"{prompt}{line}"[:box_width])
         copy_label = "[ Copy prompt ]"
         copy_x = max(box_x + 4, box_x + box_width - len(copy_label) - 2)
+        paste_label = "[ Paste ]"
+        paste_x = max(box_x + 4, copy_x - len(paste_label) - 2)
+        stdscr.addstr(box_y + 1, paste_x, paste_label[: max(0, copy_x - paste_x - 2)], curses.A_DIM)
         stdscr.addstr(box_y + 1, copy_x, copy_label[: max(0, box_width - (copy_x - box_x))], curses.A_DIM)
         stdscr.addstr(box_y + box_height - 1, box_x, bottom[:box_width], curses.A_BOLD if focused else curses.A_DIM)
 
@@ -186,10 +192,30 @@ class CobaltTUI:
                 args.extend(["-selection", "clipboard"])
             elif command == "xsel":
                 args.extend(["--clipboard", "--input"])
-            subprocess.run(args, input=text, text=True, check=True)
+            try:
+                subprocess.run(args, input=text, text=True, check=True)
+            except (OSError, subprocess.CalledProcessError):
+                continue
             return "Copied"
         raise RuntimeError("No clipboard utility found (install wl-clipboard, xclip, or xsel)")
 
+    def _paste_from_clipboard(self) -> str:
+        for command in ("wl-paste", "xclip", "xsel"):
+            executable = shutil.which(command)
+            if not executable:
+                continue
+            args = [executable]
+            if command == "xclip":
+                args.extend(["-selection", "clipboard", "-o"])
+            elif command == "xsel":
+                args.extend(["--clipboard", "--output"])
+            try:
+                result = subprocess.run(args, capture_output=True, text=True, check=True)
+            except (OSError, subprocess.CalledProcessError):
+                continue
+            return result.stdout.replace("\r\n", "\n").replace("\r", "\n")
+        raise RuntimeError("No working clipboard utility found (install wl-clipboard, xclip, or xsel)")
+
     def _latest_response(self) -> str:
         for message in reversed(self.history.messages):
             if message.get("role") == "assistant":
@@ -305,7 +331,9 @@ class CobaltTUI:
             for message_index, message in enumerate(self.history.latest(18)):
                 formatted_rows.extend((line, attr, message_index) for line, attr in self._format_message_lines(message, main_w - 8, message_index))
 
-            visible = formatted_rows[-max(1, box_y - main_y - 2):]
+            content_height = max(1, box_y - main_y - 2)
+            end = max(0, len(formatted_rows) - self.scroll_offset)
+            visible = formatted_rows[max(0, end - content_height):end]
             for idx, (line, attr, _) in enumerate(visible[: main_h - 4]):
                 y = main_y + 1 + idx
                 if y >= box_y:
@@ -371,6 +399,7 @@ class CobaltTUI:
                 self.selected_chat_path = str(target)
                 self.history = self.chat_store.load_chat(target)
                 self.current_chat = self.history
+                self.scroll_offset = 0
                 return True
         return False
 
@@ -399,6 +428,19 @@ class CobaltTUI:
                 return "response"
         return None
 
+    def _paste_button_at(self, x: int, y: int, input_text: str) -> bool:
+        height, width = curses.LINES, curses.COLS
+        sidebar_w = min(26, max(20, width // 4))
+        main_x, main_y = 3 + sidebar_w, 6
+        main_w, main_h = max(20, width - main_x - 2), max(8, height - 9)
+        _, box_y, box_width, _, _ = self._input_box_geometry(main_x, main_y, main_w, main_h, input_text)
+        label = "[ Paste ]"
+        paste_x = main_x + 2 + box_width - len("[ Copy prompt ]") - len(label) - 4
+        return paste_x <= x < paste_x + len(label) and y == box_y + 1
+
+    def _paste_into_input(self, input_text: str) -> str:
+        return input_text + self._paste_from_clipboard()
+
     def _handle_thinking_click(self, x: int, y: int) -> bool:
         height, width = curses.LINES, curses.COLS
         sidebar_w = min(26, max(20, width // 4))
@@ -440,7 +482,16 @@ class CobaltTUI:
                 ch = stdscr.getch()
 
                 if ch == curses.KEY_MOUSE:
-                    _, x, y, _, button_state = curses.getmouse()
+                    try:
+                        _, x, y, _, button_state = curses.getmouse()
+                    except curses.error:
+                        continue
+                    if button_state & getattr(curses, "BUTTON4_PRESSED", 0):
+                        self.scroll_offset = min(self.scroll_offset + 3, max(0, len(self.history.messages) * 3))
+                        continue
+                    if button_state & getattr(curses, "BUTTON5_PRESSED", 0):
+                        self.scroll_offset = max(0, self.scroll_offset - 3)
+                        continue
                     copy_target = self._copy_button_at(x, y, input_text) if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED) else None
                     if copy_target:
                         try:
@@ -448,6 +499,13 @@ class CobaltTUI:
                         except (OSError, RuntimeError, ValueError) as exc:
                             self.history.add("assistant", f"Error: {exc}")
                         continue
+                    if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED) and self._paste_button_at(x, y, input_text):
+                        try:
+                            input_text += self._paste_from_clipboard()
+                            self.input_focused = True
+                        except (OSError, RuntimeError, ValueError) as exc:
+                            self.history.add("assistant", f"Error: {exc}")
+                        continue
                     button = self._handle_button_click(x, y, stdscr.getmaxyx()[1]) if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED) else None
                     if button in ("signin", "signup"):
                         self._open_auth(button)
@@ -482,6 +540,24 @@ class CobaltTUI:
                         continue
                     self.input_focused = False
                     continue
+                if ch == 22 and self.input_focused:
+                    try:
+                        input_text = self._paste_into_input(input_text)
+                    except (OSError, RuntimeError, ValueError) as exc:
+                        self.history.add("assistant", f"Error: {exc}")
+                    continue
+                if ch == curses.KEY_UP:
+                    self.scroll_offset = min(self.scroll_offset + 1, max(0, len(self.history.messages) * 3))
+                    continue
+                if ch == curses.KEY_DOWN:
+                    self.scroll_offset = max(0, self.scroll_offset - 1)
+                    continue
+                if ch == curses.KEY_PPAGE:
+                    self.scroll_offset = min(self.scroll_offset + 8, max(0, len(self.history.messages) * 3))
+                    continue
+                if ch == curses.KEY_NPAGE:
+                    self.scroll_offset = max(0, self.scroll_offset - 8)
+                    continue
                 if self.auth_view:
                     if ch in (10, 13, curses.KEY_ENTER):
                         if self.auth_field == 0:

{cobalt_cli_linux-0.1.6 → cobalt_cli_linux-0.1.7}/src/cobalt_cli_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobalt-cli-linux
-Version: 0.1.6
+Version: 0.1.7
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT

{cobalt_cli_linux-0.1.6 → cobalt_cli_linux-0.1.7}/tests/test_cli.py

@@ -1,3 +1,4 @@
+import subprocess
 from pathlib import Path
 
 import pytest
@@ -73,6 +74,20 @@ def test_tui_copy_uses_available_clipboard_command(monkeypatch) -> None:
     assert captured["kwargs"]["input"] == "prompt text"
 
 
+def test_tui_copy_falls_back_when_xsel_fails(monkeypatch) -> None:
+    tui = CobaltTUI(settings=Settings())
+
+    monkeypatch.setattr("cobalt_cli_linux.tui.shutil.which", lambda command: f"/usr/bin/{command}")
+
+    def run(args, **kwargs):
+        if not args[0].endswith("xsel"):
+            raise subprocess.CalledProcessError(1, args)
+
+    monkeypatch.setattr("cobalt_cli_linux.tui.subprocess.run", run)
+
+    assert tui._copy_to_clipboard("text") == "Copied"
+
+
 def test_streaming_empty_answer_gets_visible_fallback(monkeypatch, tmp_path: Path) -> None:
     agent = CobaltAgent(settings=Settings(), history=ConversationHistory(tmp_path / "history.json"))
     agent.profile_store.data["active"] = "personal"
@@ -247,3 +262,34 @@ def test_groq_client_auto_detects_available_model(monkeypatch) -> None:
     client = GroqClient("test-key", model="auto")
     assert client.resolve_model() == "llama-3.3-70b-versatile"
     assert client.chat_completion([{"role": "user", "content": "hello"}]) == "ok"
+
+
+def test_groq_client_clamps_max_tokens_to_model_limit(monkeypatch) -> None:
+    captured = {}
+
+    class FakeResponse:
+        status_code = 200
+
+        def json(self):
+            return {"choices": [{"message": {"content": "ok"}}]}
+
+    class FakeClient:
+        def __init__(self, timeout=None):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def post(self, url, headers=None, json=None):
+            captured.update(json)
+            return FakeResponse()
+
+    monkeypatch.setattr("cobalt_cli_linux.groq_client.httpx.Client", FakeClient)
+    client = GroqClient("test-key", model="llama-3.1-8b-instant")
+
+    client.chat_completion([{"role": "user", "content": "hello"}], max_tokens=1024)
+
+    assert captured["max_tokens"] == 512