tass 0.1.11__tar.gz → 0.1.13__tar.gz

{tass-0.1.11 → tass-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tass
-Version: 0.1.11
+Version: 0.1.13
 Summary: A terminal assistant that allows you to ask an LLM to run commands.
 Project-URL: Homepage, https://github.com/cetincan0/tass
 Author: Can Cetin
@@ -44,11 +44,21 @@ You can run it with
 tass
 ```
 
-tass has only been tested with gpt-oss-120b using llama.cpp so far, but in theory any LLM with tool calling capabilities should work. By default, it will try connecting to http://localhost:8080. If you want to use another host, set the `TASS_HOST` environment variable. At the moment there's no support for connecting tass to a non-local API, nor are there plans for it. For the time being, I plan on keeping tass completely local. There's no telemetry, no logs, just a simple REPL loop.
+or if you only want to ask/request a single thing
+
+```
+tass "convert video.mp4 to audio.mp3"
+```
+
+tass has only been tested with llama.cpp with LLMs such as gpt-oss-120b and MiniMax M2.1, but any LLM with tool calling capabilities should work.
+
+By default, tass will try connecting to http://localhost:8080. To use another host, set the `TASS_HOST` environment variable. If your server requires an API key, you can set the `TASS_API_KEY` environment variable. At the moment there's no support for connecting tass to a non-local API, nor are there plans for it. I plan on keeping tass completely local. There's no telemetry, no logs, just a simple REPL loop.
 
 Once it's running, you can ask questions or give commands like "Create an empty file called test.txt" and it will propose a command to run after user confirmation.
 
-You can enter multiline input by ending lines with a backslash (\\). The continuation prompt will appear until you enter a line without a trailing backslash.
+You can enter multiline input by ending lines with a backslash (\\). The continuation prompt will keep appearing until you enter a line without a trailing backslash.
+
+You can use the --yolo flag to turn off user confirmations for executing commands and editing files, but I would only recommend using this if you're benchmarking tass with an LLM and highly recommend not using it outside of testing/benchmarking scenarios.
 
 ## Upgrade
 

tass-0.1.13/README.md

@@ -0,0 +1,61 @@
+# tass
+
+<p align="center">
+  <img src="assets/tass.gif" alt="Demo" />
+</p>
+
+A terminal assistant that allows you to ask an LLM to run commands.
+
+## Warning
+
+This tool can run commands including ones that can modify, move, or delete files. Use at your own risk.
+
+## Installation
+
+### Using uv
+
+```
+uv tool install tass
+```
+
+### Using pip
+
+```
+pip install tass
+```
+
+You can run it with
+
+```
+tass
+```
+
+or if you only want to ask/request a single thing
+
+```
+tass "convert video.mp4 to audio.mp3"
+```
+
+tass has only been tested with llama.cpp with LLMs such as gpt-oss-120b and MiniMax M2.1, but any LLM with tool calling capabilities should work.
+
+By default, tass will try connecting to http://localhost:8080. To use another host, set the `TASS_HOST` environment variable. If your server requires an API key, you can set the `TASS_API_KEY` environment variable. At the moment there's no support for connecting tass to a non-local API, nor are there plans for it. I plan on keeping tass completely local. There's no telemetry, no logs, just a simple REPL loop.
+
+Once it's running, you can ask questions or give commands like "Create an empty file called test.txt" and it will propose a command to run after user confirmation.
+
+You can enter multiline input by ending lines with a backslash (\\). The continuation prompt will keep appearing until you enter a line without a trailing backslash.
+
+You can use the --yolo flag to turn off user confirmations for executing commands and editing files, but I would only recommend using this if you're benchmarking tass with an LLM and highly recommend not using it outside of testing/benchmarking scenarios.
+
+## Upgrade
+
+### Using uv
+
+```
+uv tool upgrade tass
+```
+
+### Using pip
+
+```
+pip install --upgrade tass
+```

{tass-0.1.11 → tass-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tass"
-version = "0.1.11"
+version = "0.1.13"
 description = "A terminal assistant that allows you to ask an LLM to run commands."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -35,8 +35,38 @@ dev = [
     "pytest>=9.0.2",
 ]
 
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "A",
+    "B",
+    "C4",
+    "E",
+    "F",
+    "I",
+    "ISC",
+    "SIM",
+    "RUF",
+    "UP",
+    "W",
+]
+
+ignore = [
+    "E501",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["tass"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
 [tool.pyright]
 pythonVersion = "3.10"
-include = ["src/**/*.py"]
+include = ["src/**/*.py", "tests/**/*.py"]
 venvPath = "."
 venv = ".venv"

tass-0.1.13/src/app.py

@@ -0,0 +1,284 @@
+import json
+
+from prompt_toolkit import prompt
+from rich.console import Group
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+from src.constants import (
+    SYSTEM_PROMPT,
+    console,
+)
+from src.llm_client import LLMClient
+from src.tools import (
+    EDIT_FILE_TOOL,
+    EXECUTE_TOOL,
+    READ_FILE_TOOL,
+    edit_file,
+    execute,
+    read_file,
+)
+from src.utils import (
+    FileCompleter,
+    create_key_bindings,
+)
+
+
+class TassApp:
+
+    def __init__(self, yolo_mode: bool = False):
+        self.yolo_mode = yolo_mode
+        self.messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
+        self.llm_client = LLMClient()
+        self.key_bindings = create_key_bindings()
+        self.file_completer = FileCompleter()
+        self.TOOLS_MAP = {
+            "execute": execute,
+            "read_file": read_file,
+            "edit_file": edit_file,
+        }
+
+    def check_llm_host(self):
+        try:
+            response = self.llm_client.get_models()
+            console.print("Terminal Assistant [green](LLM connection ✓)[/green]")
+            if response.status_code == 200:
+                return
+        except Exception:
+            console.print("Terminal Assistant [red](LLM connection ✗)[/red]")
+
+        console.print("\n[red]Could not connect to LLM[/red]")
+        console.print(f"If your LLM isn't running on {self.llm_client.host}, you can set the [bold]TASS_HOST[/] environment variable to a different URL.")
+        new_host = console.input(
+            "Enter a different URL for this session (or press Enter to keep current): "
+        ).strip()
+
+        if new_host:
+            self.llm_client.host = new_host
+
+        try:
+            response = self.llm_client.get_models()
+            if response.status_code == 200:
+                console.print(f"[green]Connection established to {self.llm_client.host}[/green]")
+        except Exception:
+            console.print(f"[red]Unable to verify new host {self.llm_client.host}. Continuing with it anyway.[/red]")
+
+    def summarize(self):
+        max_messages = 20
+        if len(self.messages) <= max_messages:
+            return
+
+        prompt = (
+            "The conversation is becoming long and might soon go beyond the "
+            "context limit. Please provide a detailed summary of the conversation, "
+            "preserving all important details. Make sure context is not lost so that "
+            "the conversation can continue without needing to reclarify anything. "
+            "You don't have to preserve entire contents of files that have been read "
+            " or edited, they can be read again if necessary."
+        )
+
+        console.print("\n - Summarizing conversation...")
+        response = self.llm_client.get_chat_completions(
+            messages=[*self.messages, {"role": "user", "content": prompt}],
+            tools=[
+                EDIT_FILE_TOOL,
+                EXECUTE_TOOL,
+                READ_FILE_TOOL,
+            ],  # For caching purposes
+        )
+        data = response.json()
+        summary = data["choices"][0]["message"]["content"]
+        self.messages = [self.messages[0], {"role": "assistant", "content": f"Summary of the conversation so far:\n{summary}"}]
+        console.print("   [green]Summarization completed[/green]")
+
+    def call_llm(self) -> bool:
+        response = self.llm_client.get_chat_completions(
+            messages=self.messages,
+            tools=[
+                EDIT_FILE_TOOL,
+                EXECUTE_TOOL,
+                READ_FILE_TOOL,
+            ],
+            stream=True,
+        )
+
+        content = ""
+        reasoning_content = ""
+        tool_calls_map = {}
+        timings_str = ""
+
+        def generate_layout():
+            groups = []
+
+            if reasoning_content:
+                last_three_lines = "\n".join(reasoning_content.rstrip().split("\n")[-3:])
+                groups.append(Text(""))
+                groups.append(
+                    Panel(
+                        Text(
+                            last_three_lines,
+                            style="grey50",
+                        ),
+                        title="Thought process",
+                        title_align="left",
+                        subtitle=timings_str,
+                        style="grey50",
+                    )
+                )
+
+            if content:
+                groups.append(Text(""))
+                groups.append(Markdown(content.rstrip()))
+
+            return Group(*groups)
+
+        with Live(generate_layout(), refresh_per_second=10) as live:
+            for line in response.iter_lines():
+                line = line.decode("utf-8")
+                if not line.strip():
+                    continue
+
+                if line == "data: [DONE]":
+                    continue
+
+                chunk = json.loads(line.removeprefix("data:"))
+                if all(k in chunk.get("timings", {}) for k in ["prompt_n", "prompt_per_second", "predicted_n", "predicted_per_second"]):
+                    timings = chunk["timings"]
+                    timings_str = (
+                        f"Input: {timings['prompt_n']:,} tokens, {timings['prompt_per_second']:,.2f} tok/s | "
+                        f"Output: {timings['predicted_n']:,} tokens, {timings['predicted_per_second']:,.2f} tok/s"
+                    )
+
+                if chunk["choices"][0]["finish_reason"]:
+                    live.update(generate_layout())
+
+                delta = chunk["choices"][0]["delta"]
+                if not any(delta.get(key) for key in ["content", "reasoning_content", "tool_calls"]):
+                    continue
+
+                if delta.get("reasoning_content"):
+                    reasoning_content += delta["reasoning_content"]
+                    live.update(generate_layout())
+
+                if delta.get("content"):
+                    content += delta["content"]
+                    live.update(generate_layout())
+
+                for tool_call_delta in delta.get("tool_calls") or []:
+                    index = tool_call_delta["index"]
+                    if index not in tool_calls_map:
+                        tool_calls_map[index] = (
+                            {
+                                "index": index,
+                                "id": "",
+                                "type": "",
+                                "function": {
+                                    "name": "",
+                                    "arguments": "",
+                                },
+                            }
+                        )
+
+                    tool_call = tool_calls_map[index]
+                    if tool_call_delta.get("id"):
+                        tool_call["id"] += tool_call_delta["id"]
+                    if tool_call_delta.get("type"):
+                        tool_call["type"] += tool_call_delta["type"]
+                    if tool_call_delta.get("function"):
+                        function = tool_call_delta["function"]
+                        if function.get("name"):
+                            tool_call["function"]["name"] += function["name"]
+                        if function.get("arguments"):
+                            tool_call["function"]["arguments"] += function["arguments"]
+
+        self.messages.append(
+            {
+                "role": "assistant",
+                "content": content.strip(),
+                "reasoning_content": reasoning_content.strip(),
+                "tool_calls": list(tool_calls_map.values()) or [],
+            }
+        )
+
+        if not tool_calls_map:
+            return True
+
+        try:
+            for tool_call in tool_calls_map.values():
+                tool = self.TOOLS_MAP[tool_call["function"]["name"]]
+                tool_args = json.loads(tool_call["function"]["arguments"])
+                tool_args["yolo_mode"] = self.yolo_mode
+                result = tool(**tool_args)
+                self.messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "content": result,
+                    }
+                )
+            return False
+        except Exception as e:
+            self.messages.append({"role": "user", "content": f"Tool call failed: {e}"})
+            console.print(f"   [red]Tool call failed: {str(e).strip()}[/red]")
+            return self.call_llm()
+
+    def run(self, initial_input: str | None = None):
+        if initial_input:
+            self.messages.append({"role": "user", "content": initial_input})
+            while True:
+                try:
+                    finished = self.call_llm()
+                except Exception as e:
+                    console.print(f"Failed to call LLM: {e}")
+                    break
+
+                if finished:
+                    return
+
+        try:
+            self.check_llm_host()
+        except KeyboardInterrupt:
+            console.print("\nBye!")
+            return
+
+        while True:
+            console.print()
+            try:
+                input_lines = []
+                while True:
+                    input_line = prompt(
+                        "> ",
+                        completer=self.file_completer,
+                        complete_while_typing=True,
+                        key_bindings=self.key_bindings,
+                    )
+                    if not input_line or input_line[-1] != "\\":
+                        input_lines.append(input_line)
+                        break
+                    input_lines.append(input_line[:-1])
+                user_input = "\n".join(input_lines)
+            except KeyboardInterrupt:
+                console.print("\nBye!")
+                break
+
+            if not user_input:
+                continue
+
+            if user_input.lower().strip() == "exit":
+                console.print("\nBye!")
+                break
+
+            self.messages.append({"role": "user", "content": user_input})
+            while True:
+                try:
+                    finished = self.call_llm()
+                except Exception as e:
+                    console.print(f"Failed to call LLM: {e}")
+                    break
+
+                if finished:
+                    self.summarize()
+                    break

tass-0.1.13/src/cli.py

@@ -0,0 +1,27 @@
+import argparse
+
+from src.app import TassApp
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Terminal Assistant - Ask an LLM to run commands"
+    )
+    parser.add_argument(
+        "--yolo",
+        action="store_true",
+        help="YOLO mode: execute all commands and edit files without asking for confirmation",
+    )
+    parser.add_argument(
+        "prompt",
+        nargs="?",
+        help="Prompt to run (enclose in quotes; runs in single-shot mode and exits)",
+    )
+    args = parser.parse_args()
+
+    app = TassApp(yolo_mode=args.yolo)
+
+    if args.prompt:
+        app.run(initial_input=args.prompt)
+    else:
+        app.run()

tass-0.1.13/src/constants.py

@@ -0,0 +1,73 @@
+import os
+import platform
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+CWD_PATH = Path.cwd().resolve()
+
+
+def get_shell_info() -> str:
+    shell_path = os.environ.get('SHELL', '')
+    shell_name = shell_path.split('/')[-1] if shell_path else 'unknown'
+    return shell_name
+
+
+def get_git_info() -> str:
+    try:
+        git_info = []
+
+        subprocess.run(['git', 'rev-parse', '--git-dir'], capture_output=True, check=True, cwd=CWD_PATH)
+        result = subprocess.run(['git', 'branch', '--show-current'], capture_output=True, text=True, cwd=CWD_PATH)
+        branch = result.stdout.strip()
+        if branch:
+            git_info.append(f"Branch: {branch}")
+
+        result = subprocess.run(['git', 'status', '--porcelain'], capture_output=True, text=True, cwd=CWD_PATH)
+        has_changes = bool(result.stdout.strip())
+        git_info.append(f"Uncommitted changes: {'Yes' if has_changes else 'No'}")
+
+        return '\n'.join(git_info)
+    except Exception:
+        return "Not a git repository"
+
+
+def get_directory_listing() -> str:
+    try:
+        entries = []
+        iterdir = CWD_PATH.iterdir()
+        for count, entry in enumerate(sorted(iterdir)):
+            if count >= 100:
+                entries.append(f"... and {len(list(iterdir)) - 100} more items")
+                break
+            if entry.is_dir():
+                entries.append(f"{entry.name}/")
+            else:
+                entries.append(entry.name)
+        return '\n'.join(entries) if entries else "Empty directory"
+    except PermissionError:
+        return "Permission denied"
+
+
+SYSTEM_PROMPT = f"""You are tass, or Terminal Assistant, a helpful AI that executes shell commands based on natural-language requests.
+
+If the user's request involves making changes to the filesystem such as creating or deleting files or directories, you MUST first check whether the file or directory exists before proceeding.
+
+If a user asks for an answer or explanation to something instead of requesting to run a command, answer briefly and concisely. Do not supply extra information, suggestions, tips, or anything of the sort.
+
+This app has a feature where the user can refer to files or directories by typing @ which will open an file autocomplete dropdown. When this feature is used, the @ will remain in the filename. When working with said file, ignore the preceding @.
+
+Current working directory: {CWD_PATH}
+
+# Directory Context
+OS: {platform.system()}
+Shell: {get_shell_info()}
+
+# Git Info
+{get_git_info()}
+
+# Directory Listing
+{get_directory_listing()}
+"""

tass-0.1.13/src/llm_client.py

@@ -0,0 +1,49 @@
+import os
+from typing import Literal
+
+import requests
+
+
+class LLMClient:
+
+    def __init__(self):
+        self.host = os.environ.get("TASS_HOST", "http://localhost:8080")
+        self.api_key = os.environ.get("TASS_API_KEY", "")
+
+    def request(
+        self,
+        method: Literal["get", "post"],
+        url: str,
+        **kwargs,
+    ):
+        return requests.request(
+            method,
+            f"{self.host}{url}",
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+            },
+            **kwargs,
+        )
+
+    def get(self, url: str, **kwargs):
+        return self.request("get", url, **kwargs)
+
+    def post(self, url: str, **kwargs):
+        return self.request("post", url, **kwargs)
+
+    def get_models(self):
+        return self.get("/v1/models", timeout=2)
+
+    def get_chat_completions(self, messages: list[dict], tools: list[dict], stream: bool = False):
+        return self.post(
+            "/v1/chat/completions",
+            json={
+                "messages": messages,
+                "tools": tools,
+                "stream": stream,
+                "chat_template_kwargs": {
+                    "reasoning_effort": "medium",
+                },
+            },
+            stream=stream,
+        )

tass-0.1.13/src/tools/__init__.py

@@ -0,0 +1,12 @@
+from .edit_file import EDIT_FILE_TOOL, edit_file
+from .execute import EXECUTE_TOOL, execute
+from .read_file import READ_FILE_TOOL, read_file
+
+__all__ = [
+    "EDIT_FILE_TOOL",
+    "EXECUTE_TOOL",
+    "READ_FILE_TOOL",
+    "edit_file",
+    "execute",
+    "read_file",
+]