cobalt-cli-linux 0.1.0__py3-none-any.whl

cobalt_cli_linux/__init__.py

@@ -0,0 +1,5 @@
+"""Cobalt CLI package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

cobalt_cli_linux/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cobalt_cli_linux/agent.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .config import Settings
+from .executor import ShellExecutor
+from .groq_client import GroqClient
+from .history import ConversationHistory
+
+SYSTEM_PROMPT = """You are Cobalt, an expert Debian Linux assistant and DevOps engineer.
+
+Your job is to help the user safely operate the system, inspect files, run commands, and maintain a persistent local conversation.
+
+When you need to execute a shell command, read a file, or write to a file, use one of these exact formats in your response:
+- COMMAND: <shell command>
+- READ_FILE: <path>
+- WRITE_FILE: <path>
+<content>
+
+If no tool use is required, answer normally.
+"""
+
+
+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.executor = ShellExecutor(self.settings.shell)
+        self.client = GroqClient(
+            api_key=self.settings.api_key,
+            model=self.settings.model,
+            base_url=self.settings.base_url,
+        )
+
+    def _build_messages(self, prompt: str) -> list[dict[str, str]]:
+        user_messages = [{"role": "system", "content": SYSTEM_PROMPT}] + self.history.latest(20)
+        user_messages.append({"role": "user", "content": prompt})
+        return user_messages
+
+    def _execute_tool(self, tool_name: str, payload: str) -> str:
+        tool_name = tool_name.strip().upper()
+        if tool_name == "COMMAND":
+            result = self.executor.run(payload)
+            output = result.stdout.strip() or ""
+            error = result.stderr.strip()
+            summary = [f"Exit code: {result.returncode}", f"Stdout: {output}", f"Stderr: {error}"]
+            return "\n".join(part for part in summary if part)
+        if tool_name == "READ_FILE":
+            path = Path(payload.strip())
+            return path.read_text(encoding="utf-8")
+        if tool_name == "WRITE_FILE":
+            if "\n" not in payload:
+                raise ValueError("WRITE_FILE requires a path and content on separate lines")
+            path_text, content = payload.split("\n", 1)
+            path = Path(path_text.strip())
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+            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)))
+                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}"))
+        return tools
+
+    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.")
+
+        self.history.add("user", prompt)
+        messages = self._build_messages(prompt)
+        response = self.client.chat_completion(messages, temperature=self.settings.temperature, max_tokens=self.settings.max_tokens)
+
+        tool_calls = self._extract_tools(response)
+        if not tool_calls:
+            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."
+        follow_up = self.client.chat_completion(
+            [{"role": "system", "content": SYSTEM_PROMPT}] + self.history.latest(20) + [{"role": "user", "content": final_prompt}],
+            temperature=self.settings.temperature,
+            max_tokens=self.settings.max_tokens,
+        )
+        self.history.add("assistant", follow_up)
+        return follow_up
+
+    def process_stream(self, prompt: str, on_chunk=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.history.messages or self.history.messages[-1].get("role") != "user":
+            self.history.add("user", prompt)
+        else:
+            self.history.messages[-1] = {"role": "user", "content": prompt}
+            self.history.save()
+
+        messages = self._build_messages(prompt)
+        buffer = ""
+
+        if self.history.messages and self.history.messages[-1].get("role") == "assistant":
+            self.history.messages[-1]["content"] = ""
+            self.history.save()
+        else:
+            self.history.add("assistant", "")
+
+        for chunk in self.client.chat_completion_stream(messages, temperature=self.settings.temperature, max_tokens=self.settings.max_tokens):
+            buffer += chunk
+            if on_chunk is not None:
+                on_chunk(chunk)
+
+        if self.history.messages and self.history.messages[-1].get("role") == "assistant":
+            self.history.messages[-1]["content"] = buffer
+            self.history.save()
+        else:
+            self.history.add("assistant", buffer)
+        return buffer

cobalt_cli_linux/cli.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from .agent import CobaltAgent
+from .config import Settings
+from .tui import CobaltTUI
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Cobalt CLI - Debian Linux Groq agent")
+    parser.add_argument("prompt", nargs="*", help="Prompt or question to send to the assistant")
+    parser.add_argument("--interactive", "-i", action="store_true", help="Launch the full-screen interactive interface")
+    parser.add_argument("--api-key", dest="api_key", help="Groq API key; defaults to the built-in package key unless GROQ_API_KEY is set.")
+    parser.add_argument("--model", default=None, help="Groq model to use (default: auto, picks the first available model)")
+    parser.add_argument("--base-url", default=None, help="Groq API base URL")
+    parser.add_argument("--history-path", default=None, help="Path to the conversation history JSON file")
+    parser.add_argument("--shell", default=None, help="Shell executable used for commands")
+    parser.add_argument("--temperature", type=float, default=None, help="Sampling temperature for model responses")
+    parser.add_argument("--max-tokens", type=int, default=None, help="Maximum number of tokens per response")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    settings = Settings(
+        api_key=args.api_key or os.getenv("GROQ_API_KEY"),
+        model=args.model or os.getenv("GROQ_MODEL", "auto"),
+        base_url=args.base_url or os.getenv("GROQ_BASE_URL", "https://api.groq.com/openai/v1"),
+        history_path=args.history_path or os.getenv("COBALT_HISTORY_PATH", "~/.cobalt/history.json"),
+        shell=args.shell or os.getenv("SHELL", "/bin/bash"),
+        temperature=args.temperature if args.temperature is not None else 0.2,
+        max_tokens=args.max_tokens if args.max_tokens is not None else 1024,
+    )
+
+    if args.interactive:
+        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:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cobalt_cli_linux/config.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+DEFAULT_MODEL = "llama-3.3-70b-versatile"
+DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
+DEFAULT_API_KEY = "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"
+
+
+def _load_env_file() -> None:
+    for candidate in (".env", str(Path.home() / ".cobalt" / ".env"), str(Path.home() / ".env")):
+        path = Path(candidate).expanduser()
+        if not path.exists():
+            continue
+        for raw_line in path.read_text(encoding="utf-8").splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, value = [part.strip() for part in line.split("=", 1)]
+            os.environ.setdefault(key, value.strip('"\''))
+
+
+_load_env_file()
+
+
+@dataclass
+class Settings:
+    api_key: str | None = None
+    model: str = DEFAULT_MODEL
+    base_url: str = DEFAULT_BASE_URL
+    history_path: str | Path = "~/.cobalt/history.json"
+    shell: str = "/bin/bash"
+    temperature: float = 0.2
+    max_tokens: int = 1024
+
+    def __post_init__(self) -> None:
+        if self.api_key is None:
+            self.api_key = os.getenv("GROQ_API_KEY", DEFAULT_API_KEY)
+        if not self.model:
+            self.model = os.getenv("GROQ_MODEL", DEFAULT_MODEL)
+        if not self.base_url:
+            self.base_url = os.getenv("GROQ_BASE_URL", DEFAULT_BASE_URL)
+        if self.history_path is None:
+            self.history_path = os.getenv("COBALT_HISTORY_PATH", str(Path.home() / ".cobalt" / "history.json"))
+        self.history_path = Path(self.history_path).expanduser()
+        if not self.shell:
+            self.shell = os.getenv("SHELL", "/bin/bash")
+
+    @property
+    def api_key_configured(self) -> bool:
+        return bool(self.api_key)

cobalt_cli_linux/deepseek_client.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+
+class DeepSeekAPIError(RuntimeError):
+    """Raised when the DeepSeek API rejects a request."""
+
+
+class DeepSeekClient:
+    def __init__(self, api_key: str, model: str = "deepseek-chat", base_url: str = "https://api.deepseek.com") -> None:
+        if not api_key:
+            raise ValueError("DeepSeek API key is required")
+        self.api_key = api_key
+        self.model = model
+        self.base_url = base_url.rstrip("/")
+
+    def chat_completion(self, messages: list[dict[str, str]], temperature: float = 0.2, max_tokens: int = 1024) -> str:
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(f"{self.base_url}/v1/chat/completions", headers=headers, json=payload)
+
+        if response.status_code != 200:
+            try:
+                detail = response.json()
+            except ValueError:
+                detail = response.text
+            raise DeepSeekAPIError(f"DeepSeek API request failed ({response.status_code}): {detail}")
+
+        data = response.json()
+        choices = data.get("choices", [])
+        if not choices:
+            raise DeepSeekAPIError("DeepSeek API returned no choices")
+        message = choices[0].get("message", {})
+        content = message.get("content", "")
+        if not isinstance(content, str):
+            return json.dumps(content)
+        return content.strip()

cobalt_cli_linux/executor.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class CommandResult:
+    command: str
+    returncode: int
+    stdout: str
+    stderr: str
+    duration: float
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+
+class ShellExecutor:
+    """Execute commands in a POSIX shell environment."""
+
+    def __init__(self, shell: str = "/bin/bash") -> None:
+        self.shell = shell
+
+    def run(
+        self,
+        command: str,
+        cwd: Optional[str | Path] = None,
+        timeout: Optional[float] = None,
+        env: Optional[dict[str, str]] = None,
+    ) -> CommandResult:
+        started = time.monotonic()
+        completed = subprocess.run(
+            command,
+            shell=True,
+            executable=self.shell,
+            cwd=str(cwd) if cwd is not None else None,
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        duration = time.monotonic() - started
+        return CommandResult(
+            command=command,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+            duration=duration,
+        )

cobalt_cli_linux/groq_client.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import json
+from typing import Iterator
+
+import httpx
+
+
+class GroqAPIError(RuntimeError):
+    """Raised when the Groq API rejects a request."""
+
+
+class GroqClient:
+    DEFAULT_MODELS = [
+        "llama-3.3-70b-versatile",
+        "llama-3.1-8b-instant",
+        "llama-3.3-8b",
+        "mixtral-8x7b-32768",
+    ]
+
+    NON_CHAT_TOKENS = (
+        "whisper",
+        "speech",
+        "tts",
+        "audio",
+        "orpheus",
+        "playai",
+        "embedding",
+        "transcription",
+        "rasr",
+    )
+
+    def __init__(self, api_key: str, model: str = "auto", base_url: str = "https://api.groq.com/openai/v1") -> None:
+        if not api_key:
+            raise ValueError("Groq API key is required")
+        self.api_key = api_key
+        self.model = model
+        self.base_url = base_url.rstrip("/")
+
+    def _is_chat_model(self, model_id: str) -> bool:
+        lowered = model_id.lower()
+        return not any(token in lowered for token in self.NON_CHAT_TOKENS)
+
+    def resolve_model(self) -> str:
+        if self.model and self.model != "auto":
+            return self.model
+
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(f"{self.base_url}/models", headers=headers)
+
+        if response.status_code != 200:
+            return self.DEFAULT_MODELS[0]
+
+        try:
+            payload = response.json()
+        except ValueError:
+            return self.DEFAULT_MODELS[0]
+
+        ids = []
+        for item in payload.get("data", []):
+            model_id = item.get("id")
+            if model_id and self._is_chat_model(model_id):
+                ids.append(model_id)
+
+        for candidate in self.DEFAULT_MODELS:
+            if candidate in ids:
+                return candidate
+
+        if ids:
+            return ids[0]
+        return self.DEFAULT_MODELS[0]
+
+    def chat_completion(self, messages: list[dict[str, str]], temperature: float = 0.2, max_tokens: int = 1024) -> str:
+        resolved_model = self.resolve_model()
+        self.model = resolved_model
+
+        payload = {
+            "model": resolved_model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(f"{self.base_url}/chat/completions", headers=headers, json=payload)
+
+        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}")
+
+        data = response.json()
+        choices = data.get("choices", [])
+        if not choices:
+            raise GroqAPIError("Groq API returned no choices")
+        message = choices[0].get("message", {})
+        content = message.get("content", "")
+        if not isinstance(content, str):
+            return json.dumps(content)
+        return content.strip()
+
+    def chat_completion_stream(
+        self,
+        messages: list[dict[str, str]],
+        temperature: float = 0.2,
+        max_tokens: int = 1024,
+    ) -> Iterator[str]:
+        resolved_model = self.resolve_model()
+        self.model = resolved_model
+
+        payload = {
+            "model": resolved_model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": True,
+        }
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "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

cobalt_cli_linux/history.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+class ConversationHistory:
+    """Persist a conversation between a user and assistant in JSON format."""
+
+    def __init__(self, path: str | Path = "~/.cobalt/history.json", title: str | None = None) -> None:
+        self.path = Path(path).expanduser()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.title = title or self._default_title()
+        self._messages: list[dict[str, str]] = []
+        self.load()
+
+    def _default_title(self) -> str:
+        stem = self.path.stem.replace("chat-", "").replace("_", " ")
+        return stem.strip() or "new chat"
+
+    @property
+    def messages(self) -> list[dict[str, str]]:
+        return self._messages
+
+    def load(self) -> list[dict[str, str]]:
+        if self.path.exists():
+            try:
+                data = json.loads(self.path.read_text(encoding="utf-8"))
+            except json.JSONDecodeError:
+                data = []
+            if isinstance(data, dict):
+                self.title = str(data.get("title") or self.title or self._default_title())
+                data = data.get("messages", [])
+            if isinstance(data, list):
+                self._messages = [
+                    {"role": str(item.get("role", "user")), "content": str(item.get("content", ""))}
+                    for item in data
+                    if isinstance(item, dict)
+                ]
+            else:
+                self._messages = []
+        else:
+            self._messages = []
+        return self._messages
+
+    def add(self, role: str, content: str) -> None:
+        self._messages.append({"role": role, "content": content})
+        self.save()
+
+    def save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {"title": self.title or self._default_title(), "messages": self._messages}
+        self.path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+    def clear(self) -> None:
+        self._messages = []
+        self.save()
+
+    def latest(self, count: int = 10) -> list[dict[str, str]]:
+        return self._messages[-count:]
+
+    def __iter__(self):
+        return iter(self._messages)
+
+    def __len__(self) -> int:
+        return len(self._messages)
+
+    def __getitem__(self, index: int) -> dict[str, str]:
+        return self._messages[index]
+
+
+class ChatStore:
+    def __init__(self, root_dir: str | Path = "~/.cobalt/chats") -> None:
+        self.root_dir = Path(root_dir).expanduser()
+        self.root_dir.mkdir(parents=True, exist_ok=True)
+
+    def clear_all(self) -> None:
+        if self.root_dir.exists():
+            shutil.rmtree(self.root_dir)
+        self.root_dir.mkdir(parents=True, exist_ok=True)
+
+    def list_chats(self) -> list[Path]:
+        if not self.root_dir.exists():
+            return []
+        return sorted(self.root_dir.glob("*.json"))
+
+    def new_chat(self, title: str | None = None) -> ConversationHistory:
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S-%f")
+        path = self.root_dir / f"chat-{timestamp}.json"
+        history = ConversationHistory(path, title=title or "new chat")
+        history.save()
+        return history
+
+    def load_chat(self, path: str | Path) -> ConversationHistory:
+        return ConversationHistory(path)
+
+    def delete_chat(self, path: str | Path) -> bool:
+        target = Path(path).expanduser()
+        if not target.exists():
+            return False
+        target.unlink()
+        return True

cobalt_cli_linux/tui.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import curses
+import re
+import textwrap
+from pathlib import Path
+
+from .agent import CobaltAgent
+from .history import ChatStore, ConversationHistory
+
+
+class CobaltTUI:
+    def __init__(self, settings) -> None:
+        self.settings = settings
+        self.chat_store = ChatStore("~/.cobalt/chats")
+        self.chat_files = self.chat_store.list_chats()
+        self.selected_chat_path = str(self.chat_files[-1]) if self.chat_files else None
+        if not self.chat_files:
+            self.current_chat = self.chat_store.new_chat(title="New chat")
+            self.selected_chat_path = str(self.current_chat.path)
+        else:
+            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()
+
+    def _load_ascii_art(self) -> list[str]:
+        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()]
+
+    def _refresh_chat_files(self) -> None:
+        self.chat_files = self.chat_store.list_chats()
+        if not self.chat_files:
+            self.selected_chat_path = None
+            self.current_chat = self.chat_store.new_chat(title="New chat")
+            self.history = self.current_chat
+            return
+        if self.selected_chat_path is None or not any(str(path) == self.selected_chat_path for path in self.chat_files):
+            self.selected_chat_path = str(self.chat_files[-1])
+        self.current_chat = self.chat_store.load_chat(self.selected_chat_path)
+        self.history = self.current_chat
+
+    def _get_chat_display_title(self, chat_path: Path) -> str:
+        history = self.chat_store.load_chat(chat_path)
+        if history.title and history.title not in {"new chat", "New chat", "untitled"}:
+            return history.title
+        return Path(chat_path).name.replace(".json", "")
+
+    def _suggest_chat_title(self, prompt: str) -> str:
+        cleaned = re.sub(r"[^A-Za-z0-9\s-]", "", prompt).strip()
+        words = cleaned.split()
+        if not words:
+            return "New chat"
+        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 _compose_lines(self, text: str, width: int) -> list[str]:
+        lines: list[str] = []
+        for paragraph in text.splitlines() or [""]:
+            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)
+        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
+        stdscr.addstr(top, left, "+" + "-" * (width - 2) + "+")
+        for y in range(top + 1, top + height - 1):
+            stdscr.addstr(y, left, "|")
+            stdscr.addstr(y, left + width - 1, "|")
+        stdscr.addstr(top + height - 1, left, "+" + "-" * (width - 2) + "+")
+        if title:
+            title_text = f" {title} "
+            title_start = left + 2
+            stdscr.addstr(top, title_start, title_text[: max(0, width - 4)], curses.A_BOLD)
+
+    def _render(self, stdscr, input_text: str, status: str) -> None:
+        stdscr.erase()
+        stdscr.bkgd(" ", curses.color_pair(0))
+        height, width = stdscr.getmaxyx()
+
+        sidebar_w = min(26, max(20, width // 4))
+        sidebar_x = 1
+        sidebar_y = 1
+        sidebar_h = max(8, height - 4)
+        self._draw_box(stdscr, sidebar_y, sidebar_x, sidebar_h, sidebar_w, " Chats ")
+
+        chat_files = self.chat_store.list_chats()[-8:]
+        for idx, chat_path in enumerate(chat_files):
+            y = sidebar_y + 2 + idx
+            if y >= sidebar_y + sidebar_h - 2:
+                break
+            chat_name = self._get_chat_display_title(Path(chat_path))
+            display = chat_name[: max(0, sidebar_w - 5)]
+            selected = str(chat_path) == str(self.selected_chat_path) if self.selected_chat_path else False
+            if selected:
+                stdscr.addstr(y, sidebar_x + 2, display, curses.A_REVERSE)
+            else:
+                stdscr.addstr(y, sidebar_x + 2, display)
+
+        main_x = sidebar_x + sidebar_w + 2
+        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 ")
+
+        if not self.history.messages:
+            for idx, line in enumerate(self.ascii_lines):
+                y = main_y + 2 + 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)
+        else:
+            rows: list[str] = []
+            for message in self.history.latest(18):
+                role = message.get("role", "user").upper()
+                content = message.get("content", "")
+                prefix = f"[{role}] "
+                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):]
+            for idx, line in enumerate(visible[: main_h - 4]):
+                y = main_y + 1 + idx
+                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)
+
+        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:
+        buffer = ""
+
+        def on_chunk(chunk: str) -> None:
+            nonlocal buffer
+            buffer += chunk
+            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...")
+
+        agent = CobaltAgent(settings=self.settings)
+        agent.history = self.history
+        agent.process_stream(input_text.strip(), on_chunk=on_chunk)
+        self.history = agent.history
+        self.current_chat = self.history
+        self.saved_chats = self.chat_store.list_chats()
+        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)
+
+        if sidebar_x <= x < sidebar_x + sidebar_w and sidebar_y <= y < sidebar_y + sidebar_h:
+            chat_files = self.chat_store.list_chats()[-8:]
+            if not chat_files:
+                return False
+            clicked_index = y - (sidebar_y + 2)
+            if 0 <= clicked_index < len(chat_files):
+                target = chat_files[clicked_index]
+                self.selected_chat_path = str(target)
+                self.history = self.chat_store.load_chat(target)
+                self.current_chat = self.history
+                return True
+        return False
+
+    def run(self) -> int:
+        def _main(stdscr):
+            curses.curs_set(0)
+            curses.start_color()
+            curses.use_default_colors()
+            stdscr.bkgd(" ", curses.color_pair(0))
+            stdscr.nodelay(False)
+            stdscr.keypad(True)
+            curses.cbreak()
+            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"
+
+            while True:
+                self._render(stdscr, input_text, status)
+                ch = stdscr.getch()
+
+                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 = ""
+                    continue
+
+                if ch in (ord("q"), 3):
+                    break
+                if ch in (ord("n"), ord("d")) and self._should_handle_shortcut(ch, input_text):
+                    if ch == 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 == 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:
+                            if self.history.title in {"new chat", "New chat", None, ""}:
+                                self.history.title = self._suggest_chat_title(input_text.strip())
+                                self.history.save()
+                            self._stream_response(stdscr, input_text)
+                            status = "Response received"
+                        except Exception as exc:
+                            status = f"Error: {exc}"
+                        input_text = ""
+                    continue
+                if ch in (curses.KEY_BACKSPACE, 127, 8):
+                    input_text = input_text[:-1]
+                    continue
+                if ch in (curses.KEY_RESIZE,):
+                    continue
+                if 32 <= ch <= 126:
+                    input_text += chr(ch)
+                elif ch == 27:
+                    break
+
+            return 0
+
+        return curses.wrapper(_main)

cobalt_cli_linux-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: cobalt-cli-linux
+Version: 0.1.0
+Summary: Agentic Groq-powered CLI assistant for Debian Linux
+Author: Cobalt
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/owall4229/cobalt-cli-linux
+Project-URL: Repository, https://github.com/owall4229/cobalt-cli-linux
+Project-URL: Issues, https://github.com/owall4229/cobalt-cli-linux/issues
+Keywords: cli,groq,agent,linux,assistant
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# cobalt-cli-linux
+
+Cobalt is an agentic Groq-powered CLI assistant designed for Debian Linux. It can execute shell commands, read and write local files, maintain a local conversation history, and interact with Groq in a production-friendly Python package layout.
+
+## Features
+
+- Groq chat completions via HTTP client
+- Safe local shell execution with bash
+- Persistent JSON conversation history in the user's home directory
+- File read/write operations for scriptable agent workflows
+- PyPI-ready package metadata and console script entrypoint
+
+## Installation
+
+```bash
+python -m pip install cobalt-cli-linux
+```
+
+## Built-in key and .env override
+
+The CLI ships with a built-in Groq API key and uses it automatically, so end users do not have to add their own key when they install the package.
+
+If you want to override it for development or a local custom setup, create a `.env` file in the project root or in your home directory with:
+
+```bash
+GROQ_API_KEY="your_groq_key_here"
+GROQ_MODEL="llama-3.3-70b-versatile"
+GROQ_BASE_URL="https://api.groq.com/openai/v1"
+```
+
+The CLI automatically reads `.env` entries when present, but it will keep using the built-in key unless you explicitly set `GROQ_API_KEY`. The default built-in key shipped with the package is:
+
+```bash
+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
+```
+
+## Run command
+
+### Standard command mode
+
+```bash
+cobalt "List the top 10 files in the current directory"
+```
+
+### Full-screen interactive mode
+
+```bash
+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.
+
+You can also pass arguments directly:
+
+```bash
+cobalt --api-key "$GROQ_API_KEY" "Show the current user and OS info"
+```
+
+## Project layout
+
+- src/cobalt_cli_linux/agent.py - orchestration logic for tool use and model responses
+- src/cobalt_cli_linux/cli.py - command-line entrypoint
+- src/cobalt_cli_linux/groq_client.py - Groq HTTP client
+- src/cobalt_cli_linux/executor.py - shell command execution
+- src/cobalt_cli_linux/history.py - local JSON conversation history
+- src/cobalt_cli_linux/config.py - environment-based settings
+
+## Publish to PyPI
+
+From the project root, you can build and upload the package from the terminal:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine upload dist/*
+```
+
+Or with the included shortcut:
+
+```bash
+make publish
+```
+
+This creates the source and wheel distributions and uploads them to your configured PyPI account.
+
+## Notes
+
+This package is intentionally built to work on Debian Linux and uses standard POSIX shell commands. The default history file is stored at ~/.cobalt/history.json.

cobalt_cli_linux-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+cobalt_cli_linux/__init__.py,sha256=czjL-_enpn4OvExtaAxpm0gkJIoYxwE0B_HZ67LQ-3s,76
+cobalt_cli_linux/__main__.py,sha256=PSQ4rpL0dG6f-qH4N7H-gD9igQkdHzH4yVZDcW8lfZo,80
+cobalt_cli_linux/agent.py,sha256=2-SJen7yJUB0SuoZBb6HfKmN9yK9QwIImUfsUBRt0f4,6089
+cobalt_cli_linux/cli.py,sha256=bhy7He5L-zeqSqoUMFmLSYSJkQoYMClt4cYN_bopPNQ,2494
+cobalt_cli_linux/config.py,sha256=IPD8mre4AnGdJ_f9DUalEOUI-7yTny0OoCTIV9gmMJU,1845
+cobalt_cli_linux/deepseek_client.py,sha256=wcurNMePZA6IOP02veZ-nISzVNp-bt7hEgQ7LLDRHYs,1746
+cobalt_cli_linux/executor.py,sha256=rrEuwQ2Qe5qDwFgEK_A0JK9wq8DsCxNd8-z-YwSSBcs,1334
+cobalt_cli_linux/groq_client.py,sha256=bLNA2kjqahBtrWhEeBtT01GK4b81m8Hng8Sia62b3x8,5038
+cobalt_cli_linux/history.py,sha256=ev-CJatLy_cMn6lFbkj6Kh-sGQQqRy5qtwRgolmlu_M,3575
+cobalt_cli_linux/tui.py,sha256=gkB5t96fbMy-bbOT-2rx1s7jSHClrz5MOFvflUblZjM,11920
+cobalt_cli_linux-0.1.0.dist-info/METADATA,sha256=aZzFp3n02U-Cp3pE-jFx_eQwGSmYNmjWuJ7wXXa5qsk,3732
+cobalt_cli_linux-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cobalt_cli_linux-0.1.0.dist-info/entry_points.txt,sha256=QAKmkri7o0hULbLBGnnSxSFH6HFnXWDWLSIkWPvwQgs,53
+cobalt_cli_linux-0.1.0.dist-info/top_level.txt,sha256=0ih2JfV9PdRvYErd3d3EREsMKA9pt5czpgtUTt0bOP0,17
+cobalt_cli_linux-0.1.0.dist-info/RECORD,,

cobalt_cli_linux-0.1.0.dist-info/WHEEL

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

cobalt_cli_linux-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cobalt = cobalt_cli_linux.cli:main

cobalt_cli_linux-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cobalt_cli_linux