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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobalt-cli-linux
-Version: 0.1.0
+Version: 0.1.2
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT
@@ -35,6 +35,8 @@ Cobalt is an agentic Groq-powered CLI assistant designed for Debian Linux. It ca
 - File read/write operations for scriptable agent workflows
 - PyPI-ready package metadata and console script entrypoint
 
+When the agent emits a `WRITE_FILE` action, Cobalt creates the requested file using UTF-8 and verifies that the file exists with the expected contents before reporting success.
+
 ## Installation
 
 ```bash
@@ -75,6 +77,8 @@ 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.
+
 You can also pass arguments directly:
 
 ```bash

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

@@ -10,6 +10,8 @@ Cobalt is an agentic Groq-powered CLI assistant designed for Debian Linux. It ca
 - File read/write operations for scriptable agent workflows
 - PyPI-ready package metadata and console script entrypoint
 
+When the agent emits a `WRITE_FILE` action, Cobalt creates the requested file using UTF-8 and verifies that the file exists with the expected contents before reporting success.
+
 ## Installation
 
 ```bash
@@ -50,6 +52,8 @@ 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.
+
 You can also pass arguments directly:
 
 ```bash

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cobalt-cli-linux"
-version = "0.1.0"
+version = "0.1.2"
 description = "Agentic Groq-powered CLI assistant for Debian Linux"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -45,5 +45,8 @@ package-dir = {"" = "src"}
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+cobalt_cli_linux = ["ASCII.txt"]
+
 [tool.pytest.ini_options]
 pythonpath = ["src"]

cobalt_cli_linux-0.1.2/src/cobalt_cli_linux/ASCII.txt

@@ -0,0 +1,5 @@
+  ____ ___  ____    _    _   _____    ____ _     ___ 
+ / ___/ _ \| __ )  / \  | | |_   _|  / ___| |   |_ _|
+| |  | | | |  _ \ / _ \ | |   | |   | |   | |    | | 
+| |__| |_| | |_) / ___ \| |___| |   | |___| |___ | | 
+ \____\___/|____/_/   \_\_____|_|    \____|_____|___|

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

@@ -56,24 +56,49 @@ class CobaltAgent:
             path = Path(path_text.strip())
             path.parent.mkdir(parents=True, exist_ok=True)
             path.write_text(content, encoding="utf-8")
+            if not path.is_file() or path.read_text(encoding="utf-8") != content:
+                raise OSError(f"File verification failed for {path}")
             return f"Wrote {path}"
         raise ValueError(f"Unsupported tool: {tool_name}")
 
     def _extract_tools(self, response: str) -> list[tuple[str, str]]:
         tools: list[tuple[str, str]] = []
-        for line in response.splitlines():
-            match = re.match(r"^(COMMAND|READ_FILE|WRITE_FILE):\s*(.*)$", line.strip())
-            if match:
-                tools.append((match.group(1), match.group(2)))
+        lines = response.splitlines()
+        index = 0
+        while index < len(lines):
+            match = re.match(r"^(COMMAND|READ_FILE|WRITE_FILE):\s*(.*)$", lines[index].strip())
+            if not match:
+                index += 1
                 continue
-        if "WRITE_FILE:" in response:
-            match = re.search(r"WRITE_FILE:\s*(.+?)\n(.+)", response, re.DOTALL)
-            if match:
-                path = match.group(1).strip()
-                content = match.group(2)
-                tools.append(("WRITE_FILE", f"{path}\n{content}"))
+
+            tool_name, payload = match.groups()
+            if tool_name == "WRITE_FILE":
+                content_lines: list[str] = []
+                index += 1
+                while index < len(lines) and not re.match(r"^(COMMAND|READ_FILE|WRITE_FILE):\s*", lines[index].strip()):
+                    content_lines.append(lines[index])
+                    index += 1
+                tools.append((tool_name, f"{payload}\n{chr(10).join(content_lines)}"))
+                continue
+
+            tools.append((tool_name, payload))
+            index += 1
         return tools
 
+    def _tool_results(self, response: str) -> list[str]:
+        results: list[str] = []
+        for tool_name, payload in self._extract_tools(response):
+            try:
+                result = self._execute_tool(tool_name, payload)
+                results.append(f"{tool_name} result:\n{result}")
+            except (OSError, ValueError, RuntimeError) as exc:  # pragma: no cover - defensive path
+                results.append(f"{tool_name} error:\n{exc}")
+        return results
+
+    def _follow_up_messages(self, tool_results: list[str]) -> list[dict[str, str]]:
+        final_prompt = "Here are the tool result(s) from my previous action:\n\n" + "\n\n".join(tool_results) + "\n\nPlease provide the final user-facing response based on these results."
+        return [{"role": "system", "content": SYSTEM_PROMPT}] + self.history.latest(20) + [{"role": "user", "content": final_prompt}]
+
     def process(self, prompt: str) -> 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.")
@@ -87,17 +112,9 @@ class CobaltAgent:
             self.history.add("assistant", response)
             return response
 
-        tool_results: list[str] = []
-        for tool_name, payload in tool_calls:
-            try:
-                result = self._execute_tool(tool_name, payload)
-                tool_results.append(f"{tool_name} result:\n{result}")
-            except Exception as exc:  # pragma: no cover - defensive path
-                tool_results.append(f"{tool_name} error:\n{exc}")
-
-        final_prompt = "Here are the tool result(s) from my previous action:\n\n" + "\n\n".join(tool_results) + "\n\nPlease provide the final user-facing response based on these results."
+        tool_results = self._tool_results(response)
         follow_up = self.client.chat_completion(
-            [{"role": "system", "content": SYSTEM_PROMPT}] + self.history.latest(20) + [{"role": "user", "content": final_prompt}],
+            self._follow_up_messages(tool_results),
             temperature=self.settings.temperature,
             max_tokens=self.settings.max_tokens,
         )
@@ -128,6 +145,19 @@ class CobaltAgent:
             if on_chunk is not None:
                 on_chunk(chunk)
 
+        tool_results = self._tool_results(buffer)
+        if tool_results:
+            follow_up_buffer = ""
+            for chunk in self.client.chat_completion_stream(
+                self._follow_up_messages(tool_results),
+                temperature=self.settings.temperature,
+                max_tokens=self.settings.max_tokens,
+            ):
+                follow_up_buffer += chunk
+                if on_chunk is not None:
+                    on_chunk(chunk)
+            buffer = follow_up_buffer
+
         if self.history.messages and self.history.messages[-1].get("role") == "assistant":
             self.history.messages[-1]["content"] = buffer
             self.history.save()

{cobalt_cli_linux-0.1.0 → cobalt_cli_linux-0.1.2}/src/cobalt_cli_linux/cli.py

@@ -35,20 +35,16 @@ def main(argv: list[str] | None = None) -> int:
         max_tokens=args.max_tokens if args.max_tokens is not None else 1024,
     )
 
-    if args.interactive:
+    if args.interactive or not args.prompt:
         return CobaltTUI(settings).run()
 
     prompt = " ".join(args.prompt)
-    if not prompt:
-        print("Please provide a prompt or use --interactive for the full-screen UI.", file=sys.stderr)
-        return 2
-
     try:
         agent = CobaltAgent(settings=settings)
         response = agent.process(prompt)
         print(response)
         return 0
-    except Exception as exc:
+    except (OSError, RuntimeError, ValueError) as exc:
         print(f"Error: {exc}", file=sys.stderr)
         return 1
 

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

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import json
-from typing import Iterator
+from collections.abc import Iterator
+from typing import ClassVar
 
 import httpx
 
@@ -11,7 +12,7 @@ class GroqAPIError(RuntimeError):
 
 
 class GroqClient:
-    DEFAULT_MODELS = [
+    DEFAULT_MODELS: ClassVar[list[str]] = [
         "llama-3.3-70b-versatile",
         "llama-3.1-8b-instant",
         "llama-3.3-8b",
@@ -128,29 +129,31 @@ class GroqClient:
             "Content-Type": "application/json",
         }
 
-        with httpx.Client(timeout=60.0) as client:
-            with client.stream("POST", f"{self.base_url}/chat/completions", headers=headers, json=payload) as response:
-                if response.status_code != 200:
-                    try:
-                        detail = response.json()
-                    except ValueError:
-                        detail = response.text
-                    raise GroqAPIError(f"Groq API request failed ({response.status_code}): {detail}")
-
-                for line in response.iter_lines():
-                    if not line or not line.startswith("data:"):
-                        continue
-                    data = line[5:].strip()
-                    if data == "[DONE]":
-                        break
-                    try:
-                        event = json.loads(data)
-                    except json.JSONDecodeError:
-                        continue
-                    choices = event.get("choices", [])
-                    if not choices:
-                        continue
-                    delta = choices[0].get("delta", {})
-                    content = delta.get("content")
-                    if isinstance(content, str):
-                        yield content
+        with httpx.Client(timeout=60.0) as client, client.stream(
+            "POST", f"{self.base_url}/chat/completions", headers=headers, json=payload
+        ) as response:
+            if response.status_code != 200:
+                response.read()
+                try:
+                    detail = response.json()
+                except ValueError:
+                    detail = response.text
+                raise GroqAPIError(f"Groq API request failed ({response.status_code}): {detail}")
+
+            for line in response.iter_lines():
+                if not line or not line.startswith("data:"):
+                    continue
+                data = line[5:].strip()
+                if data == "[DONE]":
+                    break
+                try:
+                    event = json.loads(data)
+                except json.JSONDecodeError:
+                    continue
+                choices = event.get("choices", [])
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {})
+                content = delta.get("content")
+                if isinstance(content, str):
+                    yield content

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

@@ -6,7 +6,7 @@ import textwrap
 from pathlib import Path
 
 from .agent import CobaltAgent
-from .history import ChatStore, ConversationHistory
+from .history import ChatStore
 
 
 class CobaltTUI:
@@ -23,9 +23,12 @@ class CobaltTUI:
         self.history = self.current_chat
         self.saved_chats = self.chat_files
         self.ascii_lines = self._load_ascii_art()
+        self.input_focused = True
 
     def _load_ascii_art(self) -> list[str]:
-        ascii_path = Path(__file__).resolve().parents[2] / "ASCII.txt"
+        ascii_path = Path(__file__).with_name("ASCII.txt")
+        if not ascii_path.exists():
+            ascii_path = Path(__file__).resolve().parents[2] / "ASCII.txt"
         if not ascii_path.exists():
             return ["COBALT"]
         return [line.rstrip() for line in ascii_path.read_text(encoding="utf-8").splitlines() if line.strip()]
@@ -56,10 +59,38 @@ class CobaltTUI:
         title = " ".join(words[:4]).strip()
         return title.title() if title else "New chat"
 
-    def _should_handle_shortcut(self, ch: int, input_text: str) -> bool:
-        if input_text.strip():
-            return False
-        return ch in (ord("n"), ord("d"))
+    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 _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)
+        input_lines = textwrap.wrap(
+            input_text,
+            width=text_width,
+            replace_whitespace=False,
+            drop_whitespace=False,
+            break_long_words=True,
+            break_on_hyphens=False,
+        ) or [""]
+        max_lines = max(1, min(6, main_h - 6))
+        input_lines = input_lines[-max_lines:]
+        box_height = len(input_lines) + 3
+        box_x = main_x + 2
+        box_y = main_y + main_h - box_height - 1
+        return box_x, box_y, box_width, box_height, input_lines
+
+    def _draw_input_box(self, stdscr, box_x: int, box_y: int, box_width: int, box_height: int, input_lines: list[str], focused: bool) -> None:
+        rule = "-" * max(0, box_width - 2)
+        top_label = " Ask AI "
+        top = f"-{top_label}{rule}"
+        bottom_label = " [Enter to submit] "
+        bottom = f"-{'-' * max(0, box_width - len(bottom_label) - 2)}{bottom_label}-"
+        stdscr.addstr(box_y, box_x, top[:box_width])
+        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])
+        stdscr.addstr(box_y + box_height - 1, box_x, bottom[:box_width], curses.A_BOLD if focused else curses.A_DIM)
 
     def _compose_lines(self, text: str, width: int) -> list[str]:
         lines: list[str] = []
@@ -67,8 +98,7 @@ class CobaltTUI:
             if not paragraph:
                 lines.append("")
                 continue
-            for wrapped in textwrap.wrap(paragraph, width=max(15, width), break_long_words=False, break_on_hyphens=False):
-                lines.append(wrapped)
+            lines.extend(textwrap.wrap(paragraph, width=max(15, width), break_long_words=False, break_on_hyphens=False))
         return lines
 
     def _draw_box(self, stdscr, top: int, left: int, height: int, width: int, title: str | None = None) -> None:
@@ -89,6 +119,9 @@ class CobaltTUI:
         stdscr.bkgd(" ", curses.color_pair(0))
         height, width = stdscr.getmaxyx()
 
+        header = " Cobalt Code  |  terminal agent "
+        stdscr.addstr(0, 1, header[: max(0, width - 2)], curses.A_BOLD)
+
         sidebar_w = min(26, max(20, width // 4))
         sidebar_x = 1
         sidebar_y = 1
@@ -112,41 +145,41 @@ class CobaltTUI:
         main_w = max(20, width - main_x - 2)
         main_y = 1
         main_h = max(8, height - 4)
-        self._draw_box(stdscr, main_y, main_x, main_h, main_w, " conversation ")
+        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 = main_y + 2 + idx
+                y = art_start + idx
                 x = main_x + max(0, (main_w - len(line)) // 2)
-                stdscr.addstr(y, x, line[: max(0, main_w - 2)])
-            prompt = f"> {input_text}" if input_text else "> "
-            prompt_y = main_y + 2 + len(self.ascii_lines) + 2
-            prompt_x = main_x + max(0, (main_w - len(prompt)) // 2)
-            stdscr.addstr(prompt_y, prompt_x, prompt[: max(0, main_w - 2)], curses.A_REVERSE)
+                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}] "
+                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(4, main_h - 4):]
+            visible = rows[-max(1, box_y - main_y - 2):]
             for idx, line 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)
 
-            prompt = f"> {input_text}" if input_text else "> "
-            prompt_y = main_y + main_h - 3
-            prompt_x = main_x + max(0, (main_w - len(prompt)) // 2)
-            stdscr.addstr(prompt_y, prompt_x, prompt[: max(0, main_w - 2)], curses.A_REVERSE)
+        self._draw_input_box(stdscr, box_x, box_y, box_width, box_height, input_lines, self.input_focused)
 
-        status_line = status[: max(0, width - 1)]
-        stdscr.addstr(height - 1, 0, status_line)
-        stdscr.clrtoeol()
+        if status:
+            status_line = status[: max(0, width - 1)]
+            stdscr.addstr(height - 1, 0, status_line)
+            stdscr.clrtoeol()
         stdscr.refresh()
 
     def _stream_response(self, stdscr, input_text: str) -> str:
@@ -158,7 +191,7 @@ class CobaltTUI:
             if self.history.messages and self.history.messages[-1]["role"] == "assistant":
                 self.history.messages[-1]["content"] = buffer
                 self.history.save()
-            self._render(stdscr, input_text, "Streaming...")
+            self._render(stdscr, input_text, "")
 
         agent = CobaltAgent(settings=self.settings)
         agent.history = self.history
@@ -187,6 +220,16 @@ class CobaltTUI:
                 return True
         return False
 
+    def _click_is_in_input(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 = 3 + sidebar_w
+        main_y = 1
+        main_w = max(20, width - main_x - 2)
+        main_h = max(8, height - 4)
+        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 run(self) -> int:
         def _main(stdscr):
             curses.curs_set(0)
@@ -199,7 +242,8 @@ class CobaltTUI:
             curses.noecho()
             curses.mousemask(curses.BUTTON1_PRESSED | curses.BUTTON1_RELEASED | curses.BUTTON1_CLICKED)
             input_text = ""
-            status = "Ctrl+C or q to quit • Enter to send • n new chat • d delete chat"
+            self.input_focused = True
+            status = ""
 
             while True:
                 self._render(stdscr, input_text, status)
@@ -207,16 +251,22 @@ class CobaltTUI:
 
                 if ch == curses.KEY_MOUSE:
                     _, x, y, _, button_state = curses.getmouse()
-                    if button_state & (curses.BUTTON1_PRESSED | curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED):
-                        if self._handle_mouse_click(x, y):
-                            status = "Chat selected"
-                            input_text = ""
+                    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_mouse_click(x, y):
+                        status = "Chat selected"
+                        input_text = ""
+                        self.input_focused = False
                     continue
 
-                if ch in (ord("q"), 3):
+                if ch == 3:
                     break
-                if ch in (ord("n"), ord("d")) and self._should_handle_shortcut(ch, input_text):
-                    if ch == ord("n"):
+                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
@@ -226,7 +276,7 @@ class CobaltTUI:
                         status = "New chat started"
                         continue
 
-                    if ch == ord("d") and self.selected_chat_path:
+                    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)
@@ -250,8 +300,9 @@ class CobaltTUI:
                                 self.history.save()
                             self._stream_response(stdscr, input_text)
                             status = "Response received"
-                        except Exception as exc:
-                            status = f"Error: {exc}"
+                        except (OSError, RuntimeError, ValueError) as exc:
+                            self.history.add("assistant", f"Error: {exc}")
+                            status = ""
                         input_text = ""
                     continue
                 if ch in (curses.KEY_BACKSPACE, 127, 8):
@@ -260,9 +311,8 @@ class CobaltTUI:
                 if ch in (curses.KEY_RESIZE,):
                     continue
                 if 32 <= ch <= 126:
+                    self.input_focused = True
                     input_text += chr(ch)
-                elif ch == 27:
-                    break
 
             return 0
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobalt-cli-linux
-Version: 0.1.0
+Version: 0.1.2
 Summary: Agentic Groq-powered CLI assistant for Debian Linux
 Author: Cobalt
 License-Expression: MIT
@@ -35,6 +35,8 @@ Cobalt is an agentic Groq-powered CLI assistant designed for Debian Linux. It ca
 - File read/write operations for scriptable agent workflows
 - PyPI-ready package metadata and console script entrypoint
 
+When the agent emits a `WRITE_FILE` action, Cobalt creates the requested file using UTF-8 and verifies that the file exists with the expected contents before reporting success.
+
 ## Installation
 
 ```bash
@@ -75,6 +77,8 @@ 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.
+
 You can also pass arguments directly:
 
 ```bash

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

@@ -1,5 +1,6 @@
 README.md
 pyproject.toml
+src/cobalt_cli_linux/ASCII.txt
 src/cobalt_cli_linux/__init__.py
 src/cobalt_cli_linux/__main__.py
 src/cobalt_cli_linux/agent.py

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

@@ -1,5 +1,7 @@
 from pathlib import Path
 
+from cobalt_cli_linux import cli
+from cobalt_cli_linux.agent import CobaltAgent
 from cobalt_cli_linux.config import Settings
 from cobalt_cli_linux.executor import ShellExecutor
 from cobalt_cli_linux.groq_client import GroqClient
@@ -47,10 +49,99 @@ def test_chat_store_delete_chat(tmp_path: Path) -> None:
 def test_tui_shortcuts_ignore_typed_letters() -> None:
     tui = CobaltTUI(settings=Settings())
 
-    assert tui._should_handle_shortcut(ord("n"), "") is True
-    assert tui._should_handle_shortcut(ord("d"), "") is True
-    assert tui._should_handle_shortcut(ord("n"), "note") is False
-    assert tui._should_handle_shortcut(ord("d"), "delete") is False
+    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
+
+
+def test_q_is_not_a_shortcut_when_typing() -> None:
+    tui = CobaltTUI(settings=Settings())
+
+    assert tui._should_handle_shortcut(ord("q")) is False
+
+
+def test_no_prompt_launches_tui(monkeypatch) -> None:
+    launched = []
+
+    class FakeTUI:
+        def __init__(self, settings):
+            launched.append(settings)
+
+        def run(self):
+            return 0
+
+    monkeypatch.setattr(cli, "CobaltTUI", FakeTUI)
+
+    assert cli.main([]) == 0
+    assert launched
+
+
+def test_stream_error_reads_response_before_inspecting_body(monkeypatch) -> None:
+    class FakeResponse:
+        status_code = 401
+        text = "unauthorized"
+        was_read = False
+
+        def read(self):
+            self.was_read = True
+
+        def json(self):
+            assert self.was_read is True
+            return {"error": {"message": "unauthorized"}}
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    class FakeStreamClient:
+        def __init__(self, timeout=None):
+            self.response = FakeResponse()
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def get(self, url, headers=None):
+            return type("Response", (), {"status_code": 200, "json": lambda self: {"data": []}})()
+
+        def stream(self, method, url, headers=None, json=None):
+            return self.response
+
+    monkeypatch.setattr("cobalt_cli_linux.groq_client.httpx.Client", FakeStreamClient)
+    client = GroqClient("test-key", model="llama-3.1-8b-instant")
+
+    try:
+        next(client.chat_completion_stream([{"role": "user", "content": "hello"}]))
+    except RuntimeError as exc:
+        assert "401" in str(exc)
+    else:
+        raise AssertionError("Expected streamed API error")
+
+
+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"
+
+    result = agent._execute_tool("WRITE_FILE", f"{target}\nhello")
+
+    assert result == f"Wrote {target}"
+    assert target.read_text(encoding="utf-8") == "hello"
+
+
+def test_write_file_directive_is_parsed_once() -> None:
+    agent = CobaltAgent(settings=Settings())
+
+    tools = agent._extract_tools("WRITE_FILE: test.txt\nhello\nworld")
+
+    assert tools == [("WRITE_FILE", "test.txt\nhello\nworld")]
 
 
 def test_shell_executor_runs_command() -> None: