cobalt-cli-linux 0.1.0__tar.gz

cobalt_cli_linux-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,88 @@
+# 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/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cobalt-cli-linux"
+version = "0.1.0"
+description = "Agentic Groq-powered CLI assistant for Debian Linux"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Cobalt" }]
+license = "MIT"
+keywords = ["cli", "groq", "agent", "linux", "assistant"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Environment :: Console",
+  "Operating System :: POSIX :: Linux",
+]
+dependencies = [
+  "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/owall4229/cobalt-cli-linux"
+Repository = "https://github.com/owall4229/cobalt-cli-linux"
+Issues = "https://github.com/owall4229/cobalt-cli-linux/issues"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0.0",
+  "ruff>=0.5.0",
+  "build>=1.2.0",
+  "twine>=5.0.0",
+]
+
+[project.scripts]
+cobalt = "cobalt_cli_linux.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

cobalt_cli_linux-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cobalt_cli_linux-0.1.0/src/cobalt_cli_linux/__init__.py

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

cobalt_cli_linux-0.1.0/src/cobalt_cli_linux/__main__.py

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

cobalt_cli_linux-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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,
+        )