termchat-ai 0.1.0__tar.gz

termchat_ai-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.env
+.env.*
+!.env.example
+.netlify
+node_modules/
+.venv
+test-env/
+venv
+__pycache__/
+.pytest_cache/
+*.py[cod]
+build/
+dist/
+*.egg-info/
+.coverage
+htmlcov/

termchat_ai-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.5
+Name: termchat-ai
+Version: 0.1.0
+Summary: A no-login terminal client for the AITerminal cloud AI service
+Author: AITerminal contributors
+Keywords: ai,cli,groq,netlify,terminal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: rich<15,>=13.7
+Requires-Dist: typer<1,>=0.12
+Description-Content-Type: text/markdown
+
+# AITerminal CLI
+
+This package provides the `aiterminal` terminal command. It connects directly to the public AITerminal chat function; it does not ask users to log in and does not contain a Groq API key.
+
+## Install
+
+The package is named `termchat-ai` and is not published yet. After publication:
+
+```powershell
+py -m pip install termchat-ai
+aiterminal
+```
+
+Linux and macOS:
+
+```sh
+python -m pip install termchat-ai
+aiterminal
+```
+
+For development from a checkout:
+
+```sh
+python -m pip install ./cli
+aiterminal
+```
+
+The client uses `https://aiterminal-cloud.netlify.app` by default. Override with `AIT_TERMINAL_API_URL` if needed.
+
+Use `clear` or `/clear` to clear the screen and temporary conversation context; use `exit` or `quit` to end the session. Context is memory-only and is discarded when the process exits.

termchat_ai-0.1.0/README.md

@@ -0,0 +1,30 @@
+# AITerminal CLI
+
+This package provides the `aiterminal` terminal command. It connects directly to the public AITerminal chat function; it does not ask users to log in and does not contain a Groq API key.
+
+## Install
+
+The package is named `termchat-ai` and is not published yet. After publication:
+
+```powershell
+py -m pip install termchat-ai
+aiterminal
+```
+
+Linux and macOS:
+
+```sh
+python -m pip install termchat-ai
+aiterminal
+```
+
+For development from a checkout:
+
+```sh
+python -m pip install ./cli
+aiterminal
+```
+
+The client uses `https://aiterminal-cloud.netlify.app` by default. Override with `AIT_TERMINAL_API_URL` if needed.
+
+Use `clear` or `/clear` to clear the screen and temporary conversation context; use `exit` or `quit` to end the session. Context is memory-only and is discarded when the process exits.

termchat_ai-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "termchat-ai"
+version = "0.1.0"
+description = "A no-login terminal client for the AITerminal cloud AI service"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "AITerminal contributors" }]
+keywords = ["ai", "terminal", "groq", "netlify", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "httpx>=0.27,<1",
+  "rich>=13.7,<15",
+  "typer>=0.12,<1",
+]
+
+[project.scripts]
+aiterminal = "aiterminal.main:run"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aiterminal"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["README.md", "pyproject.toml", "src/aiterminal", "tests"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

termchat_ai-0.1.0/src/aiterminal/__init__.py

@@ -0,0 +1,4 @@
+"""AITerminal command-line client."""
+
+__version__ = "0.1.0"
+

termchat_ai-0.1.0/src/aiterminal/client.py

@@ -0,0 +1,81 @@
+"""HTTP client for the AITerminal Netlify Functions."""
+
+from __future__ import annotations
+
+import os
+from urllib.parse import urlparse
+
+import httpx
+
+DEFAULT_API_URL = "https://aiterminal-cloud.netlify.app"
+
+
+class AITerminalError(Exception):
+    """Base exception for user-safe service errors."""
+
+
+class ServiceError(AITerminalError):
+    """The backend returned a safe, user-facing error."""
+
+
+class AITerminalClient:
+    def __init__(
+        self,
+        base_url: str | None = None,
+        *,
+        transport: httpx.BaseTransport | None = None,
+        timeout: float = 35.0,
+    ) -> None:
+        configured_url = base_url or os.getenv("AIT_TERMINAL_API_URL") or DEFAULT_API_URL
+        self.base_url = configured_url.rstrip("/")
+        parsed = urlparse(self.base_url)
+        if parsed.scheme != "https" and parsed.hostname not in {"localhost", "127.0.0.1", "::1"}:
+            raise ValueError("AIT_TERMINAL_API_URL must use HTTPS (HTTP is allowed only for localhost).")
+        if not parsed.netloc:
+            raise ValueError("AIT_TERMINAL_API_URL must be an absolute URL.")
+        self._http = httpx.Client(base_url=self.base_url, timeout=timeout, transport=transport)
+
+    def ask(self, message: str, history: list[dict[str, str]]) -> str:
+        try:
+            result = self._http.post(
+                "/.netlify/functions/chat",
+                json={"message": message, "history": history},
+            )
+        except httpx.TimeoutException as exc:
+            raise ServiceError("The request timed out. Please try again.") from exc
+        except httpx.RequestError as exc:
+            raise ServiceError("Could not connect to AITerminal. Check your internet connection and try again.") from exc
+        if result.status_code == 401:
+            raise ServiceError("The request was not accepted.")
+        if result.status_code == 429:
+            raise ServiceError(self._error_message(result, "Too many requests. Please wait and try again."))
+        if result.status_code >= 500:
+            raise ServiceError(self._error_message(result, "AITerminal is temporarily unavailable."))
+        if result.status_code != 200:
+            raise ServiceError(self._error_message(result, "The request was rejected."))
+        try:
+            payload = result.json()
+        except ValueError as exc:
+            raise ServiceError("AITerminal returned an invalid response.") from exc
+        answer = payload.get("answer") if isinstance(payload, dict) else None
+        if not isinstance(answer, str) or not answer.strip():
+            raise ServiceError("AITerminal returned an invalid response.")
+        return answer
+
+    @staticmethod
+    def _error_message(result: httpx.Response, fallback: str) -> str:
+        try:
+            payload = result.json()
+        except ValueError:
+            return fallback
+        message = payload.get("error") if isinstance(payload, dict) else None
+        return message if isinstance(message, str) and message else fallback
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> AITerminalClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()

termchat_ai-0.1.0/src/aiterminal/main.py

@@ -0,0 +1,64 @@
+"""Interactive AITerminal CLI."""
+
+from __future__ import annotations
+
+import typer
+
+from .client import AITerminalClient, AITerminalError
+from .terminal import ask_question, console, show_answer
+
+app = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
+
+
+def run_conversation(client: AITerminalClient) -> None:
+    history: list[dict[str, str]] = []
+    while True:
+        try:
+            question = ask_question().strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\nGoodbye!")
+            return
+        command = question.lower()
+        if command in {"exit", "quit"}:
+            console.print("Goodbye!")
+            return
+        if command in {"clear", "/clear"}:
+            history.clear()
+            console.clear()
+            console.print("[bold]AITerminal ready![/bold]")
+            continue
+        if not question:
+            continue
+
+        try:
+            with console.status("Thinking...", spinner="dots"):
+                answer = client.ask(question, history)
+        except AITerminalError as exc:
+            console.print(f"[bold red]{exc}[/bold red]")
+            continue
+
+        show_answer(answer)
+        history.extend(({"role": "user", "content": question}, {"role": "assistant", "content": answer}))
+        del history[:-20]
+
+
+@app.callback(invoke_without_command=True)
+def main() -> None:
+    """Ask questions of the AITerminal cloud service."""
+    console.print("Connecting to AITerminal Cloud...")
+    try:
+        with AITerminalClient() as client:
+            console.print("[bold]AITerminal ready![/bold]")
+            run_conversation(client)
+    except KeyboardInterrupt:
+        console.print("\nGoodbye!")
+    except ValueError as exc:
+        console.print(f"[bold red]{exc}[/bold red]")
+
+
+def run() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    run()

termchat_ai-0.1.0/src/aiterminal/terminal.py

@@ -0,0 +1,15 @@
+"""Small Rich helpers for the interactive terminal."""
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+console = Console()
+
+
+def ask_question() -> str:
+    return console.input("[bold cyan]You> [/bold cyan]")
+
+
+def show_answer(answer: str) -> None:
+    console.print("[bold green]AI>[/bold green]")
+    console.print(Markdown(answer))

termchat_ai-0.1.0/tests/test_client.py

@@ -0,0 +1,83 @@
+import json
+
+import httpx
+import pytest
+
+from aiterminal.client import AITerminalClient, DEFAULT_API_URL, ServiceError
+
+
+def client_for(handler):
+    transport = httpx.MockTransport(handler)
+    return AITerminalClient("https://example.netlify.app", transport=transport)
+
+
+def test_chat_sends_question_and_history_without_authentication():
+    seen = []
+
+    def handler(request):
+        seen.append(request)
+        assert request.url.path == "/.netlify/functions/chat"
+        assert "authorization" not in request.headers
+        assert json.loads(request.read()) == {
+            "message": "Follow up",
+            "history": [{"role": "user", "content": "Earlier"}],
+        }
+        return httpx.Response(200, json={"answer": "A response"})
+
+    with client_for(handler) as client:
+        assert client.ask("Follow up", [{"role": "user", "content": "Earlier"}]) == "A response"
+
+    assert len(seen) == 1
+
+
+def test_rate_limit_and_server_errors_are_reported():
+    with client_for(lambda _request: httpx.Response(429, json={"error": "Request limit reached."})) as client:
+        with pytest.raises(ServiceError, match="Request limit reached"):
+            client.ask("hello", [])
+
+    with client_for(lambda _request: httpx.Response(503, json={"error": "Shared rate limiting unavailable."})) as client:
+        with pytest.raises(ServiceError, match="Shared rate limiting unavailable"):
+            client.ask("hello", [])
+
+
+def test_network_timeout_and_invalid_response_errors_are_reported():
+    def network_error(_request):
+        raise httpx.ConnectError("private connection detail")
+
+    with client_for(network_error) as client:
+        with pytest.raises(ServiceError, match="Could not connect"):
+            client.ask("hello", [])
+
+    def timeout(_request):
+        raise httpx.ReadTimeout("private timeout detail")
+
+    with client_for(timeout) as client:
+        with pytest.raises(ServiceError, match="timed out"):
+            client.ask("hello", [])
+
+    with client_for(lambda _request: httpx.Response(200, json={"unexpected": True})) as client:
+        with pytest.raises(ServiceError, match="invalid response"):
+            client.ask("hello", [])
+
+
+def test_https_is_required_outside_local_development():
+    with pytest.raises(ValueError, match="HTTPS"):
+        AITerminalClient("http://api.example.com")
+    with AITerminalClient("http://localhost:8888"):
+        pass
+
+
+def test_default_backend_url_is_used_without_configuration(monkeypatch):
+    monkeypatch.delenv("AIT_TERMINAL_API_URL", raising=False)
+    seen = []
+
+    def handler(request):
+        seen.append(request)
+        assert request.url == f"{DEFAULT_API_URL}/.netlify/functions/chat"
+        assert "authorization" not in request.headers
+        return httpx.Response(200, json={"answer": "connected"})
+
+    with AITerminalClient(transport=httpx.MockTransport(handler)) as client:
+        assert client.base_url == "https://aiterminal-cloud.netlify.app"
+        assert client.ask("hello", []) == "connected"
+    assert len(seen) == 1

termchat_ai-0.1.0/tests/test_main.py

@@ -0,0 +1,70 @@
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from aiterminal import main as main_module
+
+
+class FakeClient:
+    def __init__(self):
+        self.history_seen = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_args):
+        return None
+
+    def ask(self, question, history):
+        self.history_seen.append((question, list(history)))
+        return "answer"
+
+
+def test_cli_starts_without_authentication():
+    client = FakeClient()
+    runner = CliRunner()
+    with (
+        patch.object(main_module, "AITerminalClient", return_value=client),
+        patch.object(main_module, "run_conversation") as conversation,
+    ):
+        result = runner.invoke(main_module.app, [])
+    assert result.exit_code == 0
+    assert "Connecting to AITerminal Cloud..." in result.output
+    assert "AITerminal ready!" in result.output
+    assert "password" not in result.output.lower()
+    conversation.assert_called_once_with(client)
+
+
+def test_conversation_exit_and_context_are_session_local():
+    client = FakeClient()
+    questions = iter(["first", "second", "exit"])
+    with (
+        patch.object(main_module, "ask_question", side_effect=lambda: next(questions)),
+        patch.object(main_module, "show_answer"),
+        patch.object(main_module.console, "status") as status,
+        patch.object(main_module.console, "print"),
+    ):
+        status.return_value.__enter__.return_value = None
+        main_module.run_conversation(client)
+    assert client.history_seen[0] == ("first", [])
+    assert client.history_seen[1] == (
+        "second",
+        [{"role": "user", "content": "first"}, {"role": "assistant", "content": "answer"}],
+    )
+
+
+def test_clear_command_resets_context_and_clears_screen():
+    client = FakeClient()
+    questions = iter(["first", "clear", "second", "quit"])
+    with (
+        patch.object(main_module, "ask_question", side_effect=lambda: next(questions)),
+        patch.object(main_module, "show_answer"),
+        patch.object(main_module.console, "status") as status,
+        patch.object(main_module.console, "clear") as clear_screen,
+        patch.object(main_module.console, "print"),
+    ):
+        status.return_value.__enter__.return_value = None
+        main_module.run_conversation(client)
+    assert client.history_seen[0] == ("first", [])
+    assert client.history_seen[1] == ("second", [])
+    clear_screen.assert_called_once_with()