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

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

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

{cobalt_cli_linux-0.1.5 → 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.5"
+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.5 → cobalt_cli_linux-0.1.7}/src/cobalt_cli_linux/agent.py

@@ -169,6 +169,9 @@ class CobaltAgent:
                     on_chunk(chunk)
             buffer = follow_up_buffer
 
+        if not buffer.strip():
+            buffer = "I could not produce a visible response for that request. Please try again."
+
         if self.history.messages and self.history.messages[-1].get("role") == "assistant":
             self.history.messages[-1]["content"] = buffer
             if thinking_buffer:

{cobalt_cli_linux-0.1.5 → 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.5 → cobalt_cli_linux-0.1.7}/src/cobalt_cli_linux/tui.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import curses
 import re
+import shutil
+import subprocess
 import textwrap
 from pathlib import Path
 
@@ -30,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"
@@ -91,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:
@@ -104,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()
 
@@ -141,7 +146,7 @@ class CobaltTUI:
 
     def _input_box_geometry(self, main_x: int, main_y: int, main_w: int, main_h: int, input_text: str) -> tuple[int, int, int, int, list[str]]:
         box_width = max(20, main_w - 4)
-        text_width = max(10, box_width - 6)
+        text_width = max(10, box_width - 6 - len("[ Copy prompt ]") - 2)
         input_lines = textwrap.wrap(
             input_text,
             width=text_width,
@@ -167,8 +172,56 @@ class CobaltTUI:
         for index, line in enumerate(input_lines):
             prompt = "> " if index == 0 else "  "
             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)
 
+    def _copy_to_clipboard(self, text: str) -> str:
+        if not text:
+            raise ValueError("Nothing to copy")
+        for command in ("wl-copy", "xclip", "xsel"):
+            executable = shutil.which(command)
+            if not executable:
+                continue
+            args = [executable]
+            if command == "xclip":
+                args.extend(["-selection", "clipboard"])
+            elif command == "xsel":
+                args.extend(["--clipboard", "--input"])
+            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":
+                return message.get("content", "")
+        return ""
+
     def _compose_lines(self, text: str, width: int) -> list[str]:
         lines: list[str] = []
         for paragraph in text.splitlines() or [""]:
@@ -278,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:
@@ -286,6 +341,10 @@ class CobaltTUI:
                 clipped = line[: max(0, main_w - 4)]
                 stdscr.addstr(y, main_x + 2, clipped, attr)
 
+            copy_label = "[ Copy response ]"
+            copy_y = min(box_y - 1, main_y + main_h - box_height - 2)
+            stdscr.addstr(copy_y, main_x + 2, copy_label, curses.A_DIM)
+
         self._draw_input_box(stdscr, box_x, box_y, box_width, box_height, input_lines, self.input_focused)
 
         if status:
@@ -340,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
 
@@ -353,6 +413,34 @@ class CobaltTUI:
         box_x, box_y, box_width, box_height, _ = self._input_box_geometry(main_x, main_y, main_w, main_h, input_text)
         return box_x <= x < box_x + box_width and box_y <= y < box_y + box_height
 
+    def _copy_button_at(self, x: int, y: int, input_text: str) -> str | None:
+        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, box_height, _ = self._input_box_geometry(main_x, main_y, main_w, main_h, input_text)
+        prompt_copy_x = main_x + 2 + box_width - len("[ Copy prompt ]") - 2
+        if prompt_copy_x <= x < prompt_copy_x + len("[ Copy prompt ]") and box_y + 1 <= y <= box_y + 1:
+            return "prompt"
+        if self.history.messages:
+            copy_y = min(box_y - 1, main_y + main_h - box_height - 2)
+            if main_x + 2 <= x < main_x + 2 + len("[ Copy response ]") and y == copy_y:
+                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))
@@ -394,7 +482,30 @@ 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:
+                            self._copy_to_clipboard(self._latest_response() if copy_target == "response" else input_text)
+                        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)
@@ -429,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.5 → 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.5
+Version: 0.1.7
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT

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

@@ -1,3 +1,4 @@
+import subprocess
 from pathlib import Path
 
 import pytest
@@ -60,6 +61,45 @@ def test_tui_buttons_replace_chat_shortcuts() -> None:
     assert tui._handle_button_click(buttons["delete"][0], buttons["delete"][1], 120) == "delete"
 
 
+def test_tui_copy_uses_available_clipboard_command(monkeypatch) -> None:
+    tui = CobaltTUI(settings=Settings())
+    tui.history.add("assistant", "response text")
+    captured = {}
+
+    monkeypatch.setattr("cobalt_cli_linux.tui.shutil.which", lambda command: "/usr/bin/wl-copy" if command == "wl-copy" else None)
+    monkeypatch.setattr("cobalt_cli_linux.tui.subprocess.run", lambda args, **kwargs: captured.update(args=args, kwargs=kwargs))
+
+    assert tui._latest_response() == "response text"
+    assert tui._copy_to_clipboard("prompt text") == "Copied"
+    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"
+
+    monkeypatch.setattr(agent.client, "chat_completion_stream_events", lambda *args, **kwargs: iter(()))
+
+    response = agent.process_stream("hello")
+
+    assert response.startswith("I could not produce a visible response")
+    assert agent.history.messages[-1]["content"] == response
+
+
 def test_no_prompt_launches_tui(monkeypatch) -> None:
     launched = []
 
@@ -222,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