cobalt-cli-linux 0.1.2__tar.gz → 0.1.4__tar.gz

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobalt-cli-linux
-Version: 0.1.2
+Version: 0.1.4
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT
@@ -77,7 +77,9 @@ cobalt --interactive
 
 This launches a fullscreen TUI that feels similar to a professional agent console, with the message stream and a compact prompt area instead of a raw shell prompt.
 
-In the interface, press `Escape` to unfocus the prompt. While unfocused, `n` starts a new chat and `d` deletes the selected chat; click the prompt or type a character to focus it again. Long prompts wrap inside the prompt box.
+In the interface, click the `New chat` and `Delete chat` buttons to manage conversations. Press `Escape` to unfocus the prompt; click the prompt or type a character to focus it again. Long prompts wrap inside the prompt box.
+
+Assistant reasoning is stored separately and can be expanded by clicking its `thinking` row. Markdown headings, lists, inline backticks, and fenced code are styled in the terminal. Guest profiles are limited to three prompts per hour.
 
 You can also pass arguments directly:
 

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/README.md

@@ -52,7 +52,9 @@ cobalt --interactive
 
 This launches a fullscreen TUI that feels similar to a professional agent console, with the message stream and a compact prompt area instead of a raw shell prompt.
 
-In the interface, press `Escape` to unfocus the prompt. While unfocused, `n` starts a new chat and `d` deletes the selected chat; click the prompt or type a character to focus it again. Long prompts wrap inside the prompt box.
+In the interface, click the `New chat` and `Delete chat` buttons to manage conversations. Press `Escape` to unfocus the prompt; click the prompt or type a character to focus it again. Long prompts wrap inside the prompt box.
+
+Assistant reasoning is stored separately and can be expanded by clicking its `thinking` row. Markdown headings, lists, inline backticks, and fenced code are styled in the terminal. Guest profiles are limited to three prompts per hour.
 
 You can also pass arguments directly:
 

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/pyproject.toml

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

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/src/cobalt_cli_linux/agent.py

@@ -7,6 +7,7 @@ from .config import Settings
 from .executor import ShellExecutor
 from .groq_client import GroqClient
 from .history import ConversationHistory
+from .profiles import ProfileStore
 
 SYSTEM_PROMPT = """You are Cobalt, an expert Debian Linux assistant and DevOps engineer.
 
@@ -26,6 +27,7 @@ class CobaltAgent:
     def __init__(self, settings: Settings | None = None, history: ConversationHistory | None = None) -> None:
         self.settings = settings or Settings()
         self.history = history or ConversationHistory(self.settings.history_path)
+        self.profile_store = ProfileStore()
         self.executor = ShellExecutor(self.settings.shell)
         self.client = GroqClient(
             api_key=self.settings.api_key,
@@ -121,9 +123,11 @@ class CobaltAgent:
         self.history.add("assistant", follow_up)
         return follow_up
 
-    def process_stream(self, prompt: str, on_chunk=None) -> str:
+    def process_stream(self, prompt: str, on_chunk=None, on_thinking=None) -> str:
         if not self.settings.api_key_configured:
             raise RuntimeError("Missing Groq API key. Use the built-in key provided by the package, or set GROQ_API_KEY in a local .env file before running the CLI.")
+        if not self.profile_store.allow_prompt():
+            raise RuntimeError("Guest limit reached: 3 prompts per hour. Create a profile to continue.")
 
         if not self.history.messages or self.history.messages[-1].get("role") != "user":
             self.history.add("user", prompt)
@@ -140,7 +144,14 @@ class CobaltAgent:
         else:
             self.history.add("assistant", "")
 
-        for chunk in self.client.chat_completion_stream(messages, temperature=self.settings.temperature, max_tokens=self.settings.max_tokens):
+        thinking_buffer = ""
+        for event in self.client.chat_completion_stream_events(messages, temperature=self.settings.temperature, max_tokens=self.settings.max_tokens):
+            if event["type"] == "thinking":
+                thinking_buffer += event["text"]
+                if on_thinking is not None:
+                    on_thinking(event["text"])
+                continue
+            chunk = event["text"]
             buffer += chunk
             if on_chunk is not None:
                 on_chunk(chunk)
@@ -160,6 +171,8 @@ class CobaltAgent:
 
         if self.history.messages and self.history.messages[-1].get("role") == "assistant":
             self.history.messages[-1]["content"] = buffer
+            if thinking_buffer:
+                self.history.messages[-1]["thinking"] = thinking_buffer
             self.history.save()
         else:
             self.history.add("assistant", buffer)

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/src/cobalt_cli_linux/groq_client.py

@@ -11,6 +11,10 @@ class GroqAPIError(RuntimeError):
     """Raised when the Groq API rejects a request."""
 
 
+class GroqStreamEvent(dict[str, str]):
+    """A streamed text fragment categorized as thinking or answer content."""
+
+
 class GroqClient:
     DEFAULT_MODELS: ClassVar[list[str]] = [
         "llama-3.3-70b-versatile",
@@ -114,6 +118,16 @@ class GroqClient:
         temperature: float = 0.2,
         max_tokens: int = 1024,
     ) -> Iterator[str]:
+        for event in self.chat_completion_stream_events(messages, temperature, max_tokens):
+            if event["type"] == "content":
+                yield event["text"]
+
+    def chat_completion_stream_events(
+        self,
+        messages: list[dict[str, str]],
+        temperature: float = 0.2,
+        max_tokens: int = 1024,
+    ) -> Iterator[GroqStreamEvent]:
         resolved_model = self.resolve_model()
         self.model = resolved_model
 
@@ -154,6 +168,9 @@ class GroqClient:
                 if not choices:
                     continue
                 delta = choices[0].get("delta", {})
+                reasoning = delta.get("reasoning_content") or delta.get("thinking")
+                if isinstance(reasoning, str) and reasoning:
+                    yield GroqStreamEvent(type="thinking", text=reasoning)
                 content = delta.get("content")
-                if isinstance(content, str):
-                    yield content
+                if isinstance(content, str) and content:
+                    yield GroqStreamEvent(type="content", text=content)

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/src/cobalt_cli_linux/history.py

@@ -35,7 +35,11 @@ class ConversationHistory:
                 data = data.get("messages", [])
             if isinstance(data, list):
                 self._messages = [
-                    {"role": str(item.get("role", "user")), "content": str(item.get("content", ""))}
+                    {
+                        "role": str(item.get("role", "user")),
+                        "content": str(item.get("content", "")),
+                        **({"thinking": str(item["thinking"])} if item.get("thinking") else {}),
+                    }
                     for item in data
                     if isinstance(item, dict)
                 ]

cobalt_cli_linux-0.1.4/src/cobalt_cli_linux/profiles.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+
+class ProfileStore:
+    def __init__(self, path: str | Path = "~/.cobalt/profiles.json") -> None:
+        self.path = Path(path).expanduser()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.data = self._load()
+
+    def _load(self) -> dict:
+        if not self.path.exists():
+            return {"profiles": {"guest": {"prompts": []}}, "active": "guest"}
+        try:
+            value = json.loads(self.path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            return {"profiles": {"guest": {"prompts": []}}, "active": "guest"}
+        value.setdefault("profiles", {}).setdefault("guest", {"prompts": []})
+        value.setdefault("active", "guest")
+        return value
+
+    def save(self) -> None:
+        self.path.write_text(json.dumps(self.data, indent=2), encoding="utf-8")
+
+    @property
+    def active(self) -> str:
+        return self.data["active"]
+
+    def create(self, name: str) -> str:
+        name = " ".join(name.strip().split())
+        if not name:
+            raise ValueError("Profile name cannot be empty")
+        self.data["profiles"].setdefault(name, {"prompts": []})
+        self.data["active"] = name
+        self.save()
+        return name
+
+    def delete(self, name: str | None = None) -> bool:
+        name = name or self.active
+        if name == "guest" or name not in self.data["profiles"]:
+            return False
+        del self.data["profiles"][name]
+        self.data["active"] = "guest"
+        self.save()
+        return True
+
+    def allow_prompt(self) -> bool:
+        if self.active != "guest":
+            return True
+        now = datetime.now(timezone.utc)
+        cutoff = now - timedelta(hours=1)
+        prompts = [
+            datetime.fromisoformat(value)
+            for value in self.data["profiles"]["guest"].get("prompts", [])
+            if datetime.fromisoformat(value) >= cutoff
+        ]
+        if len(prompts) >= 3:
+            self.data["profiles"]["guest"]["prompts"] = [value.isoformat() for value in prompts]
+            self.save()
+            return False
+        prompts.append(now)
+        self.data["profiles"]["guest"]["prompts"] = [value.isoformat() for value in prompts]
+        self.save()
+        return True

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/src/cobalt_cli_linux/tui.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from .agent import CobaltAgent
 from .history import ChatStore
+from .profiles import ProfileStore
 
 
 class CobaltTUI:
@@ -22,15 +23,15 @@ class CobaltTUI:
             self.current_chat = self.chat_store.load_chat(self.selected_chat_path)
         self.history = self.current_chat
         self.saved_chats = self.chat_files
-        self.ascii_lines = self._load_ascii_art()
         self.input_focused = True
+        self.ascii_lines = self._load_ascii_art()
+        self.thinking_expanded: set[int] = set()
+        self.profile_store = ProfileStore()
 
     def _load_ascii_art(self) -> list[str]:
-        ascii_path = Path(__file__).with_name("ASCII.txt")
-        if not ascii_path.exists():
-            ascii_path = Path(__file__).resolve().parents[2] / "ASCII.txt"
+        ascii_path = Path(__file__).resolve().parents[2] / "ASCII.txt"
         if not ascii_path.exists():
-            return ["COBALT"]
+            return ["Cobalt CLI"]
         return [line.rstrip() for line in ascii_path.read_text(encoding="utf-8").splitlines() if line.strip()]
 
     def _refresh_chat_files(self) -> None:
@@ -59,8 +60,43 @@ class CobaltTUI:
         title = " ".join(words[:4]).strip()
         return title.title() if title else "New chat"
 
-    def _should_handle_shortcut(self, ch: int, input_focused: bool = False) -> bool:
-        return not input_focused and ch in (14, 4, ord("n"), ord("d"))
+    def _button_regions(self, width: int) -> dict[str, tuple[int, int, int, int]]:
+        delete_label = "[ Delete chat ]"
+        new_label = "[ New chat ]"
+        delete_x = max(1, width - len(delete_label) - 2)
+        new_x = max(1, delete_x - len(new_label) - 2)
+        return {
+            "new": (new_x, 0, len(new_label), 1),
+            "delete": (delete_x, 0, len(delete_label), 1),
+        }
+
+    def _handle_button_click(self, x: int, y: int, width: int | None = None) -> str | None:
+        screen_width = width if width is not None else curses.COLS
+        for name, (button_x, button_y, button_width, button_height) in self._button_regions(screen_width).items():
+            if button_x <= x < button_x + button_width and button_y <= y < button_y + button_height:
+                return name
+        return None
+
+    def _start_new_chat(self) -> None:
+        self.current_chat = self.chat_store.new_chat(title="New chat")
+        self.history = self.current_chat
+        self.selected_chat_path = str(self.current_chat.path)
+        self.chat_files = self.chat_store.list_chats()
+
+    def _delete_selected_chat(self) -> None:
+        if not self.selected_chat_path:
+            return
+        target = Path(self.selected_chat_path)
+        if not target.exists():
+            return
+        self.chat_store.delete_chat(target)
+        self.chat_files = self.chat_store.list_chats()
+        if self.chat_files:
+            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
+        else:
+            self._start_new_chat()
 
     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)
@@ -101,6 +137,36 @@ class CobaltTUI:
             lines.extend(textwrap.wrap(paragraph, width=max(15, width), break_long_words=False, break_on_hyphens=False))
         return lines
 
+    def _format_message_lines(self, message: dict[str, str], width: int, message_index: int) -> list[tuple[str, int]]:
+        role = message.get("role", "user").lower()
+        lines: list[tuple[str, int]] = []
+        thinking = message.get("thinking", "")
+        if role == "assistant" and thinking:
+            marker = "[-] thinking (click to expand)" if message_index not in self.thinking_expanded else "[+] thinking"
+            lines.append((marker, curses.A_DIM))
+            if message_index in self.thinking_expanded:
+                for line in self._compose_lines(thinking, max(12, width - 5)):
+                    lines.append((f"  {line}", curses.A_DIM))
+
+        in_code = False
+        has_body = False
+        for raw_line in message.get("content", "").splitlines() or [""]:
+            if raw_line.strip().startswith("```"):
+                in_code = not in_code
+                continue
+            attr = curses.A_REVERSE if in_code else curses.A_NORMAL
+            prefix = f"{role}  " if not has_body else "      "
+            if raw_line.startswith("#") or raw_line.lstrip().startswith(('-', '*')):
+                attr |= curses.A_BOLD
+            if "`" in raw_line:
+                raw_line = raw_line.replace("`", "")
+                attr |= curses.A_REVERSE
+            for line in self._compose_lines(raw_line, max(12, width - len(prefix))):
+                lines.append((f"{prefix}{line}" if prefix.strip() else line, attr))
+                prefix = "      "
+                has_body = True
+        return lines
+
     def _draw_box(self, stdscr, top: int, left: int, height: int, width: int, title: str | None = None) -> None:
         if height < 3 or width < 4:
             return
@@ -121,12 +187,17 @@ class CobaltTUI:
 
         header = " Cobalt Code  |  terminal agent "
         stdscr.addstr(0, 1, header[: max(0, width - 2)], curses.A_BOLD)
+        for name, (button_x, button_y, button_width, _) in self._button_regions(width).items():
+            label = "[ New chat ]" if name == "new" else "[ Delete chat ]"
+            stdscr.addstr(button_y, button_x, label[:button_width], curses.A_REVERSE if name == "new" else curses.A_NORMAL)
 
         sidebar_w = min(26, max(20, width // 4))
         sidebar_x = 1
-        sidebar_y = 1
-        sidebar_h = max(8, height - 4)
+        sidebar_y = 6
+        sidebar_h = max(8, height - 9)
         self._draw_box(stdscr, sidebar_y, sidebar_x, sidebar_h, sidebar_w, " Chats ")
+        profile_line = f"profile: {self.profile_store.active}"
+        stdscr.addstr(sidebar_y + 1, sidebar_x + 2, profile_line[: max(0, sidebar_w - 4)], curses.A_DIM)
 
         chat_files = self.chat_store.list_chats()[-8:]
         for idx, chat_path in enumerate(chat_files):
@@ -143,36 +214,30 @@ class CobaltTUI:
 
         main_x = sidebar_x + sidebar_w + 2
         main_w = max(20, width - main_x - 2)
-        main_y = 1
-        main_h = max(8, height - 4)
+        main_y = 6
+        main_h = max(8, height - 9)
         self._draw_box(stdscr, main_y, main_x, main_h, main_w, f" {self.history.title or 'conversation'} ")
 
         box_x, box_y, box_width, box_height, input_lines = self._input_box_geometry(main_x, main_y, main_w, main_h, input_text)
         if not self.history.messages:
-            content_height = max(1, box_y - main_y - 1)
-            art_start = main_y + max(1, (content_height - len(self.ascii_lines)) // 2)
-            for idx, line in enumerate(self.ascii_lines):
-                y = art_start + idx
+            art_start = main_y + 1
+            for index, line in enumerate(self.ascii_lines):
+                y = art_start + index
                 x = main_x + max(0, (main_w - len(line)) // 2)
                 if y < box_y:
                     stdscr.addstr(y, x, line[: max(0, main_w - 2)])
         else:
-            rows: list[str] = []
-            for message in self.history.latest(18):
-                role = message.get("role", "user").upper()
-                content = message.get("content", "")
-                prefix = f"{role.lower()}  "
-                for line in self._compose_lines(content, max(12, main_w - 8 - len(prefix))):
-                    rows.append(f"{prefix}{line}" if prefix and line else line)
-                    prefix = ""
-
-            visible = rows[-max(1, box_y - main_y - 2):]
-            for idx, line in enumerate(visible[: main_h - 4]):
+            formatted_rows: list[tuple[str, int, int]] = []
+            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):]
+            for idx, (line, attr, _) in enumerate(visible[: main_h - 4]):
                 y = main_y + 1 + idx
                 if y >= box_y:
                     break
                 clipped = line[: max(0, main_w - 4)]
-                stdscr.addstr(y, main_x + 2, clipped)
+                stdscr.addstr(y, main_x + 2, clipped, attr)
 
         self._draw_input_box(stdscr, box_x, box_y, box_width, box_height, input_lines, self.input_focused)
 
@@ -195,17 +260,28 @@ class CobaltTUI:
 
         agent = CobaltAgent(settings=self.settings)
         agent.history = self.history
-        agent.process_stream(input_text.strip(), on_chunk=on_chunk)
+        def on_thinking(chunk: str) -> None:
+            if self.history.messages and self.history.messages[-1]["role"] == "assistant":
+                self.history.messages[-1]["thinking"] = self.history.messages[-1].get("thinking", "") + chunk
+                self.history.save()
+            self._render(stdscr, input_text, "")
+
+        response = agent.process_stream(input_text.strip(), on_chunk=on_chunk, on_thinking=on_thinking)
         self.history = agent.history
         self.current_chat = self.history
         self.saved_chats = self.chat_store.list_chats()
+        if response and not buffer:
+            buffer = response
+        if not buffer:
+            raise RuntimeError("The assistant returned an empty response")
+        self._render(stdscr, "", "")
         return buffer
 
     def _handle_mouse_click(self, x: int, y: int) -> bool:
         sidebar_w = min(26, max(20, curses.COLS // 4))
         sidebar_x = 1
-        sidebar_y = 1
-        sidebar_h = max(8, curses.LINES - 4)
+        sidebar_y = 6
+        sidebar_h = max(8, curses.LINES - 9)
 
         if sidebar_x <= x < sidebar_x + sidebar_w and sidebar_y <= y < sidebar_y + sidebar_h:
             chat_files = self.chat_store.list_chats()[-8:]
@@ -224,12 +300,33 @@ class CobaltTUI:
         height, width = curses.LINES, curses.COLS
         sidebar_w = min(26, max(20, width // 4))
         main_x = 3 + sidebar_w
-        main_y = 1
+        main_y = 6
         main_w = max(20, width - main_x - 2)
-        main_h = max(8, height - 4)
+        main_h = max(8, height - 9)
         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 _handle_thinking_click(self, x: int, y: int) -> 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, _, _, _ = self._input_box_geometry(main_x, main_y, main_w, main_h, "")
+        rows: list[tuple[str, int]] = []
+        for index, message in enumerate(self.history.latest(18)):
+            rows.extend(self._format_message_lines(message, main_w - 8, index))
+        for row_index, (line, _) in enumerate(rows):
+            if main_y + 1 + row_index >= box_y:
+                break
+            if line.startswith(("[-] thinking", "[+] thinking")) and main_y + 1 + row_index == y:
+                message_index = next(index for index, message in enumerate(self.history.latest(18)) if message.get("thinking") and self._format_message_lines(message, main_w - 8, index)[0][0] == line)
+                if message_index in self.thinking_expanded:
+                    self.thinking_expanded.remove(message_index)
+                else:
+                    self.thinking_expanded.add(message_index)
+                return True
+        return False
+
     def run(self) -> int:
         def _main(stdscr):
             curses.curs_set(0)
@@ -251,11 +348,24 @@ class CobaltTUI:
 
                 if ch == curses.KEY_MOUSE:
                     _, x, y, _, button_state = curses.getmouse()
+                    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 == "new":
+                        self._start_new_chat()
+                        input_text = ""
+                        self.input_focused = True
+                        continue
+                    if button == "delete":
+                        self._delete_selected_chat()
+                        input_text = ""
+                        self.input_focused = False
+                        continue
                     if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED) and self._click_is_in_input(x, y, input_text):
                         self.input_focused = True
                         continue
+                    if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED) and self._handle_thinking_click(x, y):
+                        continue
                     if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED) and self._handle_mouse_click(x, y):
-                        status = "Chat selected"
+                        status = ""
                         input_text = ""
                         self.input_focused = False
                     continue
@@ -265,33 +375,6 @@ class CobaltTUI:
                 if ch == 27:
                     self.input_focused = False
                     continue
-                if self._should_handle_shortcut(ch, self.input_focused):
-                    if ch in (14, ord("n")):
-                        new_chat = self.chat_store.new_chat(title="New chat")
-                        self.current_chat = new_chat
-                        self.history = self.current_chat
-                        self.selected_chat_path = str(self.current_chat.path)
-                        self.chat_files = self.chat_store.list_chats()
-                        input_text = ""
-                        status = "New chat started"
-                        continue
-
-                    if ch in (4, ord("d")) and self.selected_chat_path:
-                        target = Path(self.selected_chat_path)
-                        if target.exists():
-                            self.chat_store.delete_chat(target)
-                            self.chat_files = self.chat_store.list_chats()
-                            if self.chat_files:
-                                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
-                            else:
-                                self.current_chat = self.chat_store.new_chat(title="New chat")
-                                self.history = self.current_chat
-                                self.selected_chat_path = str(self.current_chat.path)
-                            input_text = ""
-                            status = "Chat deleted"
-                            continue
                 if ch in (10, 13, curses.KEY_ENTER):
                     if input_text.strip():
                         try:
@@ -299,7 +382,7 @@ class CobaltTUI:
                                 self.history.title = self._suggest_chat_title(input_text.strip())
                                 self.history.save()
                             self._stream_response(stdscr, input_text)
-                            status = "Response received"
+                            status = ""
                         except (OSError, RuntimeError, ValueError) as exc:
                             self.history.add("assistant", f"Error: {exc}")
                             status = ""

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/src/cobalt_cli_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobalt-cli-linux
-Version: 0.1.2
+Version: 0.1.4
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT
@@ -77,7 +77,9 @@ cobalt --interactive
 
 This launches a fullscreen TUI that feels similar to a professional agent console, with the message stream and a compact prompt area instead of a raw shell prompt.
 
-In the interface, press `Escape` to unfocus the prompt. While unfocused, `n` starts a new chat and `d` deletes the selected chat; click the prompt or type a character to focus it again. Long prompts wrap inside the prompt box.
+In the interface, click the `New chat` and `Delete chat` buttons to manage conversations. Press `Escape` to unfocus the prompt; click the prompt or type a character to focus it again. Long prompts wrap inside the prompt box.
+
+Assistant reasoning is stored separately and can be expanded by clicking its `thinking` row. Markdown headings, lists, inline backticks, and fenced code are styled in the terminal. Guest profiles are limited to three prompts per hour.
 
 You can also pass arguments directly:
 

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/src/cobalt_cli_linux.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/cobalt_cli_linux/deepseek_client.py
 src/cobalt_cli_linux/executor.py
 src/cobalt_cli_linux/groq_client.py
 src/cobalt_cli_linux/history.py
+src/cobalt_cli_linux/profiles.py
 src/cobalt_cli_linux/tui.py
 src/cobalt_cli_linux.egg-info/PKG-INFO
 src/cobalt_cli_linux.egg-info/SOURCES.txt

{cobalt_cli_linux-0.1.2 → cobalt_cli_linux-0.1.4}/tests/test_cli.py

@@ -6,6 +6,7 @@ from cobalt_cli_linux.config import Settings
 from cobalt_cli_linux.executor import ShellExecutor
 from cobalt_cli_linux.groq_client import GroqClient
 from cobalt_cli_linux.history import ChatStore, ConversationHistory
+from cobalt_cli_linux.profiles import ProfileStore
 from cobalt_cli_linux.tui import CobaltTUI
 
 
@@ -46,22 +47,15 @@ def test_chat_store_delete_chat(tmp_path: Path) -> None:
     assert store.list_chats()[0].name == second.path.name
 
 
-def test_tui_shortcuts_ignore_typed_letters() -> None:
+def test_tui_buttons_replace_chat_shortcuts() -> None:
     tui = CobaltTUI(settings=Settings())
 
-    assert tui._should_handle_shortcut(14) is True
-    assert tui._should_handle_shortcut(4) is True
-    assert tui._should_handle_shortcut(ord("n")) is True
-    assert tui._should_handle_shortcut(ord("d")) is True
-    assert tui._should_handle_shortcut(ord("q")) is False
-    assert tui._should_handle_shortcut(ord("n"), True) is False
-    assert tui._should_handle_shortcut(ord("d"), True) is False
+    buttons = tui._button_regions(120)
 
-
-def test_q_is_not_a_shortcut_when_typing() -> None:
-    tui = CobaltTUI(settings=Settings())
-
-    assert tui._should_handle_shortcut(ord("q")) is False
+    assert buttons["new"][2] == len("[ New chat ]")
+    assert buttons["delete"][2] == len("[ Delete chat ]")
+    assert tui._handle_button_click(buttons["new"][0], buttons["new"][1], 120) == "new"
+    assert tui._handle_button_click(buttons["delete"][0], buttons["delete"][1], 120) == "delete"
 
 
 def test_no_prompt_launches_tui(monkeypatch) -> None:
@@ -126,6 +120,26 @@ def test_stream_error_reads_response_before_inspecting_body(monkeypatch) -> None
         raise AssertionError("Expected streamed API error")
 
 
+def test_profiles_create_delete_and_guest_limit(tmp_path: Path) -> None:
+    store = ProfileStore(tmp_path / "profiles.json")
+
+    assert store.allow_prompt() is True
+    assert store.allow_prompt() is True
+    assert store.allow_prompt() is True
+    assert store.allow_prompt() is False
+    assert store.create("personal") == "personal"
+    assert store.allow_prompt() is True
+    assert store.delete("personal") is True
+    assert store.active == "guest"
+
+
+def test_tui_empty_chat_does_not_load_prompt_art_as_body_content(tmp_path: Path) -> None:
+    tui = CobaltTUI(settings=Settings())
+
+    assert tui.ascii_lines
+    assert tui.ascii_lines[0].strip().startswith("____")
+
+
 def test_write_file_tool_creates_and_verifies_file(tmp_path: Path) -> None:
     agent = CobaltAgent(settings=Settings(), history=ConversationHistory(tmp_path / "history.json"))
     target = tmp_path / "test.txt"