tarmina 0.1.0__py3-none-any.whl

tarmina/__init__.py

@@ -0,0 +1,13 @@
+import sys
+import io
+
+if sys.platform == "win32":
+    try:
+        sys.stdout = io.TextIOWrapper(
+            sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True
+        )
+        sys.stderr = io.TextIOWrapper(
+            sys.stderr.buffer, encoding="utf-8", errors="replace", line_buffering=True
+        )
+    except Exception:
+        pass

tarmina/ai.py

@@ -0,0 +1,157 @@
+from typing import AsyncGenerator
+from dataclasses import dataclass
+
+
+@dataclass
+class AIConfig:
+    provider: str
+    model: str
+    api_key: str = ""
+    base_url: str = ""
+    temperature: float = 0.8
+    max_tokens: int = 2048
+
+
+class AIProvider:
+    def __init__(self, config: AIConfig):
+        self.config = config
+
+    async def chat(self, messages: list[dict], system_prompt: str = "") -> str:
+        raise NotImplementedError
+
+    async def stream(self, messages: list[dict], system_prompt: str = "") -> AsyncGenerator[str, None]:
+        raise NotImplementedError
+
+
+class OpenAIProvider(AIProvider):
+    def __init__(self, config: AIConfig):
+        super().__init__(config)
+        from openai import AsyncOpenAI
+        kwargs = {"api_key": config.api_key, "max_retries": 2}
+        if config.base_url:
+            kwargs["base_url"] = config.base_url
+        self.client = AsyncOpenAI(**kwargs)
+
+    def _build(self, messages, system_prompt):
+        msgs = []
+        if system_prompt:
+            msgs.append({"role": "system", "content": system_prompt})
+        msgs.extend(messages)
+        return msgs
+
+    async def chat(self, messages, system_prompt=""):
+        r = await self.client.chat.completions.create(
+            model=self.config.model,
+            messages=self._build(messages, system_prompt),
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+        )
+        return r.choices[0].message.content or ""
+
+    async def stream(self, messages, system_prompt=""):
+        s = await self.client.chat.completions.create(
+            model=self.config.model,
+            messages=self._build(messages, system_prompt),
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            stream=True,
+        )
+        async for chunk in s:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+
+
+class OllamaProvider(AIProvider):
+    def __init__(self, config: AIConfig):
+        super().__init__(config)
+        self.base = config.base_url.rstrip("/") if config.base_url else "http://localhost:11434"
+
+    def _build(self, messages, system_prompt):
+        msgs = []
+        if system_prompt:
+            msgs.append({"role": "system", "content": system_prompt})
+        msgs.extend(messages)
+        return msgs
+
+    async def chat(self, messages, system_prompt=""):
+        import aiohttp
+        import json
+        async with aiohttp.ClientSession() as s:
+            async with s.post(f"{self.base}/api/chat", json={
+                "model": self.config.model, "messages": self._build(messages, system_prompt),
+                "stream": False, "options": {"temperature": self.config.temperature},
+            }) as r:
+                data = await r.json()
+                return data.get("message", {}).get("content", "")
+
+    async def stream(self, messages, system_prompt=""):
+        import aiohttp
+        import json
+        async with aiohttp.ClientSession() as s:
+            async with s.post(f"{self.base}/api/chat", json={
+                "model": self.config.model, "messages": self._build(messages, system_prompt),
+                "stream": True, "options": {"temperature": self.config.temperature},
+            }) as r:
+                buf = ""
+                async for line in r.content:
+                    line = line.decode().strip()
+                    if not line:
+                        continue
+                    try:
+                        chunk = json.loads(line)
+                        content = chunk.get("message", {}).get("content", "")
+                        if content:
+                            yield content
+                    except Exception:
+                        continue
+
+
+class GroqProvider(AIProvider):
+    def __init__(self, config: AIConfig):
+        super().__init__(config)
+        from groq import AsyncGroq
+        self.client = AsyncGroq(api_key=config.api_key)
+
+    def _build(self, messages, system_prompt):
+        msgs = []
+        if system_prompt:
+            msgs.append({"role": "system", "content": system_prompt})
+        msgs.extend(messages)
+        return msgs
+
+    async def chat(self, messages, system_prompt=""):
+        r = await self.client.chat.completions.create(
+            model=self.config.model,
+            messages=self._build(messages, system_prompt),
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+        )
+        return r.choices[0].message.content or ""
+
+    async def stream(self, messages, system_prompt=""):
+        s = await self.client.chat.completions.create(
+            model=self.config.model,
+            messages=self._build(messages, system_prompt),
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            stream=True,
+        )
+        async for chunk in s:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+
+
+PROVIDERS = {
+    "openai": OpenAIProvider,
+    "openrouter": OpenAIProvider,
+    "ollama": OllamaProvider,
+    "groq": GroqProvider,
+    "custom": OpenAIProvider,
+}
+
+
+def create_provider(config: AIConfig) -> AIProvider:
+    cls = PROVIDERS.get(config.provider)
+    if not cls:
+        raise ValueError(f"Unknown provider: {config.provider}. Options: {list(PROVIDERS.keys())}")
+    return cls(config)

tarmina/app.py

@@ -0,0 +1,372 @@
+import asyncio
+import time
+from textual.app import App, ComposeResult
+from textual.widgets import TextArea, Static, ListView, ListItem, Input
+from textual.containers import Container
+from textual.binding import Binding
+
+from .ai import create_provider, AIConfig
+from .config import get_ai_config, get_personality, get_system_config, get_memory_config
+from .memory import Memory
+from .tools.system import SystemTools, execute_tool_call
+
+
+def _safe(text: str) -> str:
+    try:
+        text.encode("cp1252")
+    except UnicodeEncodeError:
+        text = text.encode("cp1252", errors="replace").decode("cp1252", errors="replace")
+    return text.strip()
+
+
+class CommandPalette(Container):
+    COMMANDS = [
+        ("/clear", "Clear chat history"),
+        ("/exit", "Exit the app"),
+        ("/help", "Show help"),
+        ("/newsession", "Start a new session"),
+        ("/sessions", "List all sessions"),
+        ("/status", "Show system status"),
+    ]
+
+    def __init__(self, on_select):
+        super().__init__(id="palette")
+        self._on_select = on_select
+
+    def compose(self) -> ComposeResult:
+        yield ListView(id="palette-list")
+
+    def on_mount(self):
+        self._update_list()
+        self.query_one("#palette-list", ListView).focus()
+
+    def _update_list(self, selected_idx: int = 0):
+        lv = self.query_one("#palette-list", ListView)
+        lv.clear()
+        for i, (cmd, desc) in enumerate(self.COMMANDS):
+            mark = "[*]" if i == selected_idx else "[ ]"
+            lv.append(ListItem(
+                Static(f"  {mark} [bold #e5e7eb]{cmd}[/] - [#484f58]{desc}[/]", id="cmd-item")
+            ))
+        lv.index = selected_idx
+
+    def on_list_view_highlighted(self, event: ListView.Highlighted):
+        if event.item and event.item.children:
+            self._update_list(event.list_view.index or 0)
+
+    def on_list_view_selected(self, event: ListView.Selected):
+        if event.item is not None:
+            idx = event.list_view.index
+            if idx is not None and 0 <= idx < len(self.COMMANDS):
+                self._on_select(self.COMMANDS[idx][0])
+
+
+class TarminaApp(App):
+    CSS_PATH = "tarmina.css"
+
+    BINDINGS = [
+        Binding("escape", "quit", "Quit"),
+        Binding("ctrl+l", "clear_chat", "Clear"),
+        Binding("ctrl+n", "submit", "Send", show=False),
+        Binding("ctrl+c", "ignore_ctrl_c", "Copy", show=False),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.ai_config = AIConfig(**get_ai_config())
+        self.personality = get_personality()
+        self.memory = Memory(get_memory_config())
+        self.tools = SystemTools(get_system_config())
+        self.provider = None
+        self._thinking = False
+        self._lines = []
+        self._tokens = 0
+        self._cost = 0.0
+
+    def _init_provider(self):
+        try:
+            self.provider = create_provider(self.ai_config)
+        except Exception as e:
+            self._add(f"AI init failed: {_safe(str(e))}")
+
+    def compose(self) -> ComposeResult:
+        yield TextArea(text="", read_only=True, show_line_numbers=False, id="output")
+        self._palette = CommandPalette(on_select=self._on_cmd_select)
+        self._palette.display = False
+        yield self._palette
+        yield TextArea(text="", show_line_numbers=False, id="input")
+        with Container(id="sep"):
+            yield Static(f"[bold #d97706]{self.memory.session_id}[/] · [bold #e5e7eb]{self.ai_config.model}[/] {self.ai_config.provider}", id="build-info")
+        with Container(id="menu"):
+            yield Static("", id="usage")
+            yield Static("[bold #e5e7eb]Ctrl+N[/] send  [bold #e5e7eb]Enter[/] newline  [bold #e5e7eb]Esc[/] quit  [bold #e5e7eb]Ctrl+L[/] clear", id="shortcuts")
+
+    def on_mount(self):
+        self._init_provider()
+        if not self.provider:
+            self._add("AI not configured. Run: tarmina --setup")
+            self.query_one("#input", TextArea).focus()
+            return
+
+        try:
+            from pyfiglet import Figlet
+            logo = Figlet(font="banner3", width=80).renderText("TARMINA").rstrip()
+        except ImportError:
+            logo = "Tarmina"
+        for line in logo.split("\n"):
+            self._lines.append(f"  {line}")
+        self._lines.append("")
+        self._lines.append(f"  {self.ai_config.provider} / {self.ai_config.model}")
+        self._lines.append(f"  session: {self.memory.session_id}")
+        self._lines.append(f"  {self.memory.count()} messages")
+        self._lines.append("  " + "\u2500" * 78)
+        self._flush()
+        self.query_one("#input", TextArea).focus()
+
+    def on_text_area_changed(self, event: TextArea.Changed):
+        if event.text_area.id != "input":
+            return
+        text = event.text_area.text
+        if text == "/":
+            self._palette.display = True
+            self._palette.query_one("#palette-list", ListView).focus()
+            self._palette._update_list()
+        elif self._palette.display and text != "/":
+            self._palette.display = False
+            self.query_one("#input", TextArea).focus()
+
+    def _on_cmd_select(self, cmd: str):
+        self._palette.display = False
+        self._handle_command(cmd)
+        self.query_one("#input", TextArea).text = ""
+        self.query_one("#input", TextArea).focus()
+
+    def action_submit(self):
+        if self._thinking:
+            return
+        inp = self.query_one("#input", TextArea)
+        text = inp.text.strip()
+        inp.text = ""
+        if not text:
+            return
+        if text.startswith("/"):
+            self._handle_command(text)
+            return
+        self._lines.append("")
+        self._lines.append(f"  \u25b8 {_safe(text)}")
+        self._lines.append("")
+        self._lines.append("  Thinking...")
+        self._flush()
+        self._thinking = True
+        self._think_start = time.time()
+        self.run_worker(self._chat(text))
+        self.run_worker(self._thinking_timer())
+
+    def _add(self, text: str):
+        self._lines.append(f"  {text}")
+        self._flush()
+
+    def _flush(self):
+        out = self.query_one("#output", TextArea)
+        out.text = "\n".join(self._lines[-500:])
+        out.scroll_end(animate=False)
+
+    async def _thinking_timer(self):
+        import asyncio as _asyncio
+        while self._thinking:
+            elapsed = time.time() - self._think_start
+            if self._lines and "Thinking" in self._lines[-1]:
+                self._lines[-1] = f"  Thinking... {elapsed:.1f}s"
+                self._flush()
+            await _asyncio.sleep(0.5)
+
+    def _parse_tool_call(self, text: str) -> dict | None:
+        import json as _json
+        idx = text.find('"tool"')
+        if idx == -1:
+            return None
+        start = text.rfind("{", 0, idx)
+        if start == -1:
+            return None
+        depth = 0
+        for i in range(start, len(text)):
+            if text[i] == "{":
+                depth += 1
+            elif text[i] == "}":
+                depth -= 1
+                if depth == 0:
+                    try:
+                        obj = _json.loads(text[start:i+1])
+                        if "tool" in obj and "args" in obj:
+                            return obj
+                    except Exception:
+                        pass
+                    return None
+        return None
+
+    async def _handle_tool(self, tool_call: dict) -> dict:
+        self._add(f"[tool] {tool_call['tool']}({tool_call['args']})")
+        self._flush()
+        result = await execute_tool_call(tool_call, self.tools)
+        if "error" in result:
+            self._add(f"  error: {result['error'][:200]}")
+        elif "message" in result:
+            self._add(f"  {result['message']}")
+        self._flush()
+        return result
+
+    async def _chat(self, text: str):
+        start = time.time()
+        sp = self.personality.get("system_prompt", "")
+        if self.tools.allow_commands or self.tools.allow_apps:
+            sp += "\n\n" + self.tools.get_tools_prompt()
+
+        msgs = self.memory.get_messages(limit=40)
+        msgs.append({"role": "user", "content": text})
+
+        try:
+            full = ""
+            async for chunk in self.provider.stream(msgs, sp):
+                full += chunk
+
+            self.memory.add("user", text)
+
+            tool_call = self._parse_tool_call(full)
+            if tool_call:
+                result = await self._handle_tool(tool_call)
+                result_text = _safe(str(result.get("stdout", result.get("content", result.get("message", str(result))))))
+                msgs.append({"role": "assistant", "content": full})
+                msgs.append({"role": "user", "content": f"Tool result: {result_text}"})
+                await self._tool_loop(msgs, sp, start)
+            else:
+                self._display_response(full)
+
+            self._lines.append(f"  Thought: {(time.time() - start):.1f}s")
+            self._lines.append("")
+            self._flush()
+
+            total_chars = sum(len(m["content"]) for m in msgs) + len(full)
+            self._tokens += total_chars // 4
+            self._cost += total_chars * 0.0000001
+            self._update_usage()
+        except Exception as e:
+            self._add(f"Error: {_safe(str(e)[:200])}")
+
+        self._thinking = False
+
+    async def _tool_loop(self, msgs: list, sp: str, start: float):
+        for _ in range(5):
+            full = ""
+            async for chunk in self.provider.stream(msgs, sp):
+                full += chunk
+
+            tool_call = self._parse_tool_call(full)
+            if not tool_call:
+                self._display_response(full)
+                return
+
+            result = await self._handle_tool(tool_call)
+            result_text = _safe(str(result.get("stdout", result.get("content", result.get("message", str(result))))))
+            msgs.append({"role": "assistant", "content": full})
+            msgs.append({"role": "user", "content": f"Tool result: {result_text}"})
+
+        self._display_response(full)
+
+    def _display_response(self, response: str):
+        if self._lines and "Thinking..." in self._lines[-1]:
+            self._lines.pop()
+        if self._lines and self._lines[-1].strip() == "":
+            self._lines.pop()
+        self._lines.append("")
+        for line in _safe(response).split("\n"):
+            self._lines.append(f"  {line}")
+        self._lines.append("")
+        self._flush()
+        self.memory.add("assistant", _safe(response))
+
+    def _update_usage(self):
+        try:
+            w = self.query_one("#usage", Static)
+            if self._tokens >= 1000:
+                ts = f"{self._tokens/1000:.1f}K"
+            else:
+                ts = str(self._tokens)
+            pct = min(self._tokens * 100 / 200000, 99)
+            w.update(f"[#484f58]{ts} ([#e5e7eb]{pct:.0f}%[/]) \xb7 [/#484f58]${self._cost:.2f}")
+        except Exception:
+            pass
+
+    def _handle_command(self, cmd: str):
+        parts = cmd.split(maxsplit=1)
+        name = parts[0].lower()
+        arg = parts[1] if len(parts) > 1 else ""
+
+        if name in ("/exit", "/quit"):
+            self.exit()
+        elif name == "/clear":
+            self.memory.clear()
+            self._lines.clear()
+            self._flush()
+        elif name == "/help":
+            self._add("/help /clear /status /exit /sessions /session /newsession")
+        elif name == "/sessions":
+            all_sessions = Memory.list_sessions()
+            if not all_sessions:
+                self._add("No saved sessions.")
+                return
+            current = self.memory.session_id
+            for s in all_sessions:
+                marker = ">" if s["id"] == current else " "
+                self._add(f"{marker} {s['id']} ({s['count']} msgs) {s['preview'][:50]}")
+        elif name == "/session":
+            if not arg:
+                self._add(f"Current session: {self.memory.session_id}")
+                return
+            if self.memory.switch_session(arg):
+                self._lines.clear()
+                self._add(f"Switched to session: {arg}")
+                self._flush()
+                try:
+                    w = self.query_one("#build-info", Static)
+                    w.update(f"[bold #d97706]{self.memory.session_id}[/] · [bold #e5e7eb]{self.ai_config.model}[/] {self.ai_config.provider}")
+                except Exception:
+                    pass
+            else:
+                self._add(f"Session not found: {arg}")
+        elif name == "/newsession":
+            old_id = self.memory.session_id
+            self.memory = Memory(get_memory_config())
+            self._lines.clear()
+            self._add(f"New session: {self.memory.session_id} (was {old_id})")
+            self._flush()
+            try:
+                w = self.query_one("#build-info", Static)
+                w.update(f"[bold #d97706]{self.memory.session_id}[/] · [bold #e5e7eb]{self.ai_config.model}[/] {self.ai_config.provider}")
+            except Exception:
+                pass
+        elif name == "/save":
+            self._add(f"Session {self.memory.session_id} ({self.memory.count()} msgs)")
+        elif name == "/status":
+            try:
+                import psutil
+                self._add(f"CPU {psutil.cpu_percent()}%  RAM {psutil.virtual_memory().percent}%  Disk {psutil.disk_usage('/').percent}%")
+            except ImportError:
+                self._add(f"{self.ai_config.provider} / {self.ai_config.model}")
+        else:
+            self._add(f"Unknown: {name}")
+
+    def action_ignore_ctrl_c(self):
+        pass
+
+    def action_quit(self):
+        if self._palette.display:
+            self._palette.display = False
+            self.query_one("#input", TextArea).text = ""
+            self.query_one("#input", TextArea).focus()
+            return
+        self.exit()
+
+    def action_clear_chat(self):
+        self._lines.clear()
+        self._flush()
+        self.memory.clear()