tass 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

src/app.py

@@ -1,11 +1,7 @@
 import json
-import os
-import subprocess
-from pathlib import Path
 
-import requests
 from prompt_toolkit import prompt
-from rich.console import Console, Group
+from rich.console import Group
 from rich.live import Live
 from rich.markdown import Markdown
 from rich.panel import Panel
@@ -13,34 +9,40 @@ from rich.text import Text
 
 from src.constants import (
     SYSTEM_PROMPT,
-    TOOLS,
+    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,
-    is_read_only_command,
 )
 
-console = Console()
-
 
 class TassApp:
 
-    def __init__(self):
+    def __init__(self, yolo_mode: bool = False):
+        self.yolo_mode = yolo_mode
         self.messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
-        self.host = os.environ.get("TASS_HOST", "http://localhost:8080")
+        self.llm_client = LLMClient()
         self.key_bindings = create_key_bindings()
         self.file_completer = FileCompleter()
         self.TOOLS_MAP = {
-            "execute": self.execute,
-            "read_file": self.read_file,
-            "edit_file": self.edit_file,
+            "execute": execute,
+            "read_file": read_file,
+            "edit_file": edit_file,
         }
 
-    def _check_llm_host(self):
-        test_url = f"{self.host}/v1/models"
+    def check_llm_host(self):
         try:
-            response = requests.get(test_url, timeout=2)
+            response = self.llm_client.get_models()
             console.print("Terminal Assistant [green](LLM connection ✓)[/green]")
             if response.status_code == 200:
                 return
@@ -48,20 +50,20 @@ class TassApp:
             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.host}, you can set the [bold]TASS_HOST[/] environment variable to a different URL.")
+        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.host = new_host
+            self.llm_client.host = new_host
 
         try:
-            response = requests.get(f"{self.host}/v1/models", timeout=2)
+            response = self.llm_client.get_models()
             if response.status_code == 200:
-                console.print(f"[green]Connection established to {self.host}[/green]")
+                console.print(f"[green]Connection established to {self.llm_client.host}[/green]")
         except Exception:
-            console.print(f"[red]Unable to verify new host {self.host}. Continuing with it anyway.[/red]")
+            console.print(f"[red]Unable to verify new host {self.llm_client.host}. Continuing with it anyway.[/red]")
 
     def summarize(self):
         max_messages = 20
@@ -78,15 +80,13 @@ class TassApp:
         )
 
         console.print("\n - Summarizing conversation...")
-        response = requests.post(
-            f"{self.host}/v1/chat/completions",
-            json={
-                "messages": self.messages + [{"role": "user", "content": prompt}],
-                "tools": TOOLS,  # For caching purposes
-                "chat_template_kwargs": {
-                    "reasoning_effort": "medium",
-                },
-            },
+        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"]
@@ -94,16 +94,13 @@ class TassApp:
         console.print("   [green]Summarization completed[/green]")
 
     def call_llm(self) -> bool:
-        response = requests.post(
-            f"{self.host}/v1/chat/completions",
-            json={
-                "messages": self.messages,
-                "tools": TOOLS,
-                "chat_template_kwargs": {
-                    "reasoning_effort": "medium",
-                },
-                "stream": True,
-            },
+        response = self.llm_client.get_chat_completions(
+            messages=self.messages,
+            tools=[
+                EDIT_FILE_TOOL,
+                EXECUTE_TOOL,
+                READ_FILE_TOOL,
+            ],
             stream=True,
         )
 
@@ -158,7 +155,7 @@ class TassApp:
                     live.update(generate_layout())
 
                 delta = chunk["choices"][0]["delta"]
-                if not any([delta.get(key) for key in ["content", "reasoning_content", "tool_calls"]]):
+                if not any(delta.get(key) for key in ["content", "reasoning_content", "tool_calls"]):
                     continue
 
                 if delta.get("reasoning_content"):
@@ -212,6 +209,7 @@ class TassApp:
             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(
                     {
@@ -223,177 +221,25 @@ class TassApp:
                 )
             return False
         except Exception as e:
-            self.messages.append({"role": "user", "content": str(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 read_file(self, path: str, start: int = 1, num_lines: int = 1000) -> str:
-        if start == 1 and num_lines == 1000:
-            console.print(f" └ Reading file [bold]{path}[/]...")
-        else:
-            last_line = start + num_lines - 1
-            console.print(f" └ Reading file [bold]{path}[/] (lines {start}-{last_line})...")
-
-        try:
-            result = subprocess.run(
-                f"cat -n {path}",
-                shell=True,
-                capture_output=True,
-                text=True,
-            )
-        except Exception as e:
-            console.print("   [red]read_file failed[/red]")
-            console.print(f"   [red]{str(e).strip()}[/red]")
-            return f"read_file failed: {str(e)}"
-
-        out = result.stdout
-        err = result.stderr.strip()
-        if result.returncode != 0:
-            console.print("   [red]read_file failed[/red]")
-            if err:
-                console.print(f"   [red]{err}[/red]")
-            return f"read_file failed: {err}"
-
-        lines = []
-        line_num = 1
-        for line in out.split("\n"):
-            if line_num < start:
-                line_num += 1
-                continue
-
-            lines.append(line)
-            line_num += 1
-
-            if len(lines) >= num_lines:
-                lines.append("... (truncated)")
-                break
-
-        console.print("   [green]Command succeeded[/green]")
-        return "\n".join(lines)
-
-    def edit_file(self, path: str, edits: list[dict]) -> str:
-        for edit in edits:
-            edit["applied"] = False
-
-        def find_edit(n: int) -> dict | None:
-            for edit in edits:
-                if edit["line_start"] <= n <= edit["line_end"]:
-                    return edit
-
-            return None
-
-        file_exists = Path(path).exists()
-        if file_exists:
-            with open(path, "r") as f:
-                original_content = f.read()
-        else:
-            original_content = ""
-
-        final_lines = []
-        original_lines = original_content.split("\n")
-        diff_text = f"{'Editing' if file_exists else 'Creating'} {path}"
-        for i, line in enumerate(original_lines):
-            line_num = i + 1
-            edit = find_edit(line_num)
-            if not edit:
-                final_lines.append(line)
-                continue
-
-            if edit["applied"]:
-                continue
-
-            replace_lines = edit["content"].split("\n")
-            if edit["content"]:
-                final_lines.extend(replace_lines)
-            original_lines = original_content.split("\n")
-            replaced_lines = original_lines[edit["line_start"] - 1:edit["line_end"]]
-
-            prev_line_num = line_num if line_num == 1 else line_num - 1
-            line_before = "" if i == 0 else f" {original_lines[i - 1]}\n"
-            line_after = "" if edit["line_end"] == len(original_lines) else f"\n {original_lines[edit['line_end']]}"
-            replaced_with_minuses = "\n".join([f"-{line}" for line in replaced_lines]) if file_exists else ""
-            replaced_with_pluses = ""
-            if edit["content"]:
-                replaced_with_pluses = "\n" + "\n".join([f"+{line}" for line in edit["content"].split("\n")])
-            diff_text = f"{diff_text}\n\n@@ -{prev_line_num},{len(replaced_lines)} +{prev_line_num},{len(replace_lines)} @@\n{line_before}{replaced_with_minuses}{replaced_with_pluses}{line_after}"
-            edit["applied"] = True
-
-        console.print()
-        console.print(Markdown(f"```diff\n{diff_text}\n```"))
-        answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
-        if answer not in ("yes", "y", ""):
-            reason = console.input("Why not? (optional, press Enter to skip): ").strip()
-            return f"User declined: {reason or 'no reason'}"
-
-        console.print(" └ Running...")
-        try:
-            with open(path, "w") as f:
-                f.write("\n".join(final_lines))
-        except Exception as e:
-            console.print("   [red]edit_file failed[/red]")
-            console.print(f"   [red]{str(e).strip()}[/red]")
-            return f"edit_file failed: {str(e).strip()}"
-
-        console.print("   [green]Command succeeded[/green]")
-        return f"Successfully edited {path}"
-
-    def execute(self, command: str, explanation: str) -> str:
-        command = command.strip()
-        requires_confirmation = not is_read_only_command(command)
-        if requires_confirmation:
-            console.print()
-            console.print(Markdown(f"```shell\n{command}\n```"))
-            if explanation:
-                console.print(f"Explanation: {explanation}")
-            answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
-            if answer not in ("yes", "y", ""):
-                reason = console.input("Why not? (optional, press Enter to skip): ").strip()
-                return f"User declined: {reason or 'no reason'}"
-
-        if requires_confirmation:
-            console.print(" └ Running...")
-        else:
-            console.print(f" └ Running [bold]{command}[/] (Explanation: {explanation})...")
-
-        try:
-            result = subprocess.run(
-                command,
-                shell=True,
-                capture_output=True,
-                text=True,
-            )
-        except Exception as e:
-            console.print("   [red]subprocess.run failed[/red]")
-            console.print(f"   [red]{str(e).strip()}[/red]")
-            return f"subprocess.run failed: {str(e).strip()}"
-
-        out = result.stdout
-        err = result.stderr.strip()
-        if result.returncode == 0:
-            console.print("   [green]Command succeeded[/green]")
-        else:
-            console.print(f"   [red]Command failed[/red] (code {result.returncode})")
-            if err:
-                console.print(f"   [red]{err}[/red]")
-
-        if len(out.split("\n")) > 1000:
-            out_first_1000 = "\n".join(out.split("\n")[:1000])
-            out = f"{out_first_1000}... (Truncated)"
-
-        if len(err.split("\n")) > 1000:
-            err_first_1000 = "\n".join(err.split("\n")[:1000])
-            err = f"{err_first_1000}... (Truncated)"
-
-        if len(out) > 20000:
-            out = f"{out[:20000]}... (Truncated)"
-
-        if len(err) > 20000:
-            err = f"{err[:20000]}... (Truncated)"
+    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
 
-        return f"Command output (exit {result.returncode}):\n{out}\n{err}"
+                if finished:
+                    return
 
-    def run(self):
         try:
-            self._check_llm_host()
+            self.check_llm_host()
         except KeyboardInterrupt:
             console.print("\nBye!")
             return
@@ -426,12 +272,11 @@ class TassApp:
                 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: {str(e)}")
+                    console.print(f"Failed to call LLM: {e}")
                     break
 
                 if finished:

src/cli.py

@@ -1,6 +1,27 @@
+import argparse
+
 from src.app import TassApp
 
 
 def main():
-    app = TassApp()
-    app.run()
+    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()

src/constants.py

@@ -1,6 +1,55 @@
+import os
+import platform
+import subprocess
 from pathlib import Path
 
-cwd_path = Path.cwd().resolve()
+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.
 
@@ -8,115 +57,17 @@ If the user's request involves making changes to the filesystem such as creating
 
 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.
 
-Current working directory: {cwd_path}"""
-
-TOOLS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "execute",
-            "description": "Executes a shell command.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "command": {
-                        "type": "string",
-                        "description": "Full shell command to be executed.",
-                    },
-                    "explanation": {
-                        "type": "string",
-                        "description": "A brief explanation of why you want to run this command. Keep it to a single sentence.",
-                    },
-                },
-                "required": ["command", "explanation"],
-                "$schema": "http://json-schema.org/draft-07/schema#",
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "edit_file",
-            "description": "Edits (or creates) a file. Can make multiple edits in one call. Each edit replaces the contents between 'line_start' and 'line_end' inclusive with 'content'. If creating a file, only return a single edit where 'line_start' and 'line_end' are both 1 and 'content' is the entire contents of the file. You must use the read_file tool before editing a file.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "type": "string",
-                        "description": "Relative path of the file",
-                    },
-                    "edits": {
-                        "type": "array",
-                        "description": "List of edits to apply. Each edit must contain 'line_start', 'line_end', and 'content'.",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "line_start": {
-                                    "type": "integer",
-                                    "description": "The first line to remove (inclusive)",
-                                },
-                                "line_end": {
-                                    "type": "integer",
-                                    "description": "The last line to remove (inclusive)",
-                                },
-                                "content": {
-                                    "type": "string",
-                                    "description": "The content to replace with. Must have the correct spacing and indentation for all lines.",
-                                },
-                            },
-                            "required": ["line_start", "line_end", "content"],
-                        },
-                    },
-                },
-                "required": ["path", "edits"],
-                "$schema": "http://json-schema.org/draft-07/schema#",
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "read_file",
-            "description": "Read a file's contents (the first 1000 lines by default). When reading a file for the first time, do not change the defaults and always read the first 1000 lines unless you are absolutely certain of which lines need to be read. The output will be identical to calling `cat -n <path>` with preceding spaces, line number and a tab.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "type": "string",
-                        "description": "Relative path of the file",
-                    },
-                    "start": {
-                        "type": "integer",
-                        "description": "Which line to start reading from",
-                        "default": 1,
-                    },
-                    "num_lines": {
-                        "type": "integer",
-                        "description": "Number of lines to read, defaults to 1000",
-                        "default": 1000,
-                    },
-                },
-                "required": ["path"],
-                "$schema": "http://json-schema.org/draft-07/schema#",
-            },
-        },
-    },
-]
-
-READ_ONLY_COMMANDS = [
-    "ls",
-    "cat",
-    "less",
-    "more",
-    "echo",
-    "head",
-    "tail",
-    "wc",
-    "grep",
-    "find",
-    "ack",
-    "which",
-    "sed",
-    "find",
-    "test",
-]
+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()}
+"""

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,
+        )

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",
+]

src/tools/edit_file.py

@@ -0,0 +1,180 @@
+from dataclasses import dataclass
+from difflib import SequenceMatcher, unified_diff
+from pathlib import Path
+
+from rich.markdown import Markdown
+
+from src.constants import console
+
+EDIT_FILE_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "edit_file",
+        "description": "Edits (or creates) a file. Can make multiple edits in one call. Each edit finds the instance of 'find' and replaces it with 'replace'. When creating a file, only return a single edit where 'find' is empty and 'replace' is the entire contents of the file. Both 'find' and 'replace' must always be entire lines and never parts of a line, and they must always have correct dnd complete indentation. You must use the read_file tool before editing a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Relative path of the file",
+                },
+                "edits": {
+                    "type": "array",
+                    "description": "List of edits to apply.",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "find": {
+                                "type": "string",
+                                "description": "Content to find. Include additional previous/following lines if necessary to uniquely identify the section.",
+                            },
+                            "replace": {
+                                "type": "string",
+                                "description": "The content to replace with. Must have the correct spacing and indentation for all lines.",
+                            },
+                        },
+                        "required": ["find", "replace"],
+                    },
+                },
+            },
+            "required": ["path", "edits"],
+            "$schema": "http://json-schema.org/draft-07/schema#",
+        },
+    },
+}
+
+
+@dataclass
+class LineEdit:
+
+    line_start: int
+    line_end: int
+    replace: str
+    applied: bool = False
+
+
+def remove_empty_lines(s: str) -> str:
+    while "\n\n" in s:
+        s = s.replace("\n\n", "\n")
+    return s
+
+
+def fuzzy_match(edit_find: str, lines: list[str]) -> tuple[int, int] | None:
+    if not lines:
+        return None
+
+    num_edit_find_lines = len(edit_find.split("\n"))
+    edit_find_trimmed = remove_empty_lines(edit_find)
+    best_ratio = 0.0
+    best_start = -1
+    best_window_len = 1
+    for i in range(len(lines)):
+        for j in range(1, min(num_edit_find_lines * 2, len(lines) - i)):
+            window_text = remove_empty_lines("\n".join(lines[i : i + j]))
+            ratio = SequenceMatcher(None, edit_find_trimmed, window_text).ratio()
+            if ratio > best_ratio:
+                best_ratio = ratio
+                best_start = i
+                best_window_len = j
+                if best_ratio == 1.0:
+                    return best_start + 1, best_start + best_window_len
+
+    if best_ratio >= 0.9:
+        return best_start + 1, best_start + best_window_len
+
+    return None
+
+
+def convert_edit_to_line_edit(edit: dict, original_content: str) -> LineEdit:
+    if not original_content and not edit["find"]:
+        return LineEdit(1, 1, edit["replace"], False)
+
+    lines = original_content.split("\n")
+    edit_lines = edit["find"].split("\n")
+
+    # First try exact matches
+    for i in range(len(lines)):
+        if lines[i : i + len(edit_lines)] == edit_lines:
+            return LineEdit(i + 1, i + len(edit_lines), edit["replace"], False)
+
+    # Then try matching without spacing
+    for i in range(len(lines)):
+        stripped_lines = [line.strip() for line in lines[i : i + len(edit_lines)]]
+        stripped_edit_lines = [line.strip() for line in edit_lines]
+        if stripped_lines == stripped_edit_lines:
+            return LineEdit(i + 1, i + len(edit_lines), edit["replace"], False)
+
+    # Finally try sequence matching while ignoring whitespace
+    fuzzy_edit = fuzzy_match(edit["find"], lines)
+    if fuzzy_edit:
+        return LineEdit(*fuzzy_edit, edit["replace"], False)
+
+    raise Exception("Edit not found in file")
+
+
+def edit_file(path: str, edits: list[dict], yolo_mode: bool = False) -> str:
+    def find_line_edit(n: int) -> LineEdit | None:
+        for line_edit in line_edits:
+            if line_edit.line_start <= n <= line_edit.line_end:
+                return line_edit
+
+        return None
+
+    file_exists = Path(path).exists()
+    if file_exists:
+        with open(path) as f:
+            original_content = f.read()
+    else:
+        original_content = ""
+
+    line_edits: list[LineEdit] = [
+        convert_edit_to_line_edit(edit, original_content)
+        for edit in edits
+    ]
+
+    final_lines = []
+    original_lines = original_content.split("\n")
+    for i, line in enumerate(original_lines):
+        line_num = i + 1
+        line_edit = find_line_edit(line_num)
+        if not line_edit:
+            final_lines.append(line)
+            continue
+
+        if line_edit.applied:
+            continue
+
+        replace_lines = line_edit.replace.split("\n")
+        if line_edit.replace:
+            final_lines.extend(replace_lines)
+        original_lines = original_content.split("\n")
+        line_edit.applied = True
+
+    unified_diff_md = ""
+    for line in unified_diff(
+        [f"{line}\n" for line in original_lines],
+        [f"{line}\n" for line in final_lines],
+        fromfile=path,
+        tofile=path,
+    ):
+        unified_diff_md += line
+
+    console.print()
+    console.print(Markdown(f"```diff\n{unified_diff_md}\n```"))
+
+    if not yolo_mode:
+        answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
+        if answer not in ("yes", "y", ""):
+            reason = console.input("Why not? (optional, press Enter to skip): ").strip()
+            return f"User declined: {reason or 'no reason'}"
+    console.print(" └ Running...")
+    try:
+        with open(path, "w") as f:
+            f.write("\n".join(final_lines))
+    except Exception as e:
+        console.print("   [red]edit_file failed[/red]")
+        console.print(f"   [red]{str(e).strip()}[/red]")
+        return f"edit_file failed: {str(e).strip()}"
+
+    console.print("   [green]Command succeeded[/green]")
+    return f"Successfully edited {path}"

src/tools/execute.py

@@ -0,0 +1,121 @@
+import subprocess
+
+from rich.markdown import Markdown
+
+from src.constants import (
+    CWD_PATH,
+    console,
+)
+
+READ_ONLY_COMMANDS = [
+    "ls",
+    "cat",
+    "less",
+    "more",
+    "echo",
+    "head",
+    "tail",
+    "wc",
+    "grep",
+    "find",
+    "ack",
+    "which",
+    "sed",
+    "find",
+    "test",
+]
+
+EXECUTE_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "execute",
+        "description": f"Executes a shell command. The current working directory for all commands will be {CWD_PATH}",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "Full shell command to be executed.",
+                },
+                "explanation": {
+                    "type": "string",
+                    "description": "A brief explanation of why you want to run this command. Keep it to a single sentence.",
+                },
+            },
+            "required": ["command", "explanation"],
+            "$schema": "http://json-schema.org/draft-07/schema#",
+        },
+    },
+}
+
+
+def is_read_only_command(command: str) -> bool:
+    """A simple check to see if the command is only for reading files.
+
+    Not a comprehensive or foolproof check by any means, and will
+    return false negatives to be safe.
+    """
+    if ">" in command:
+        return False
+
+    # Replace everything that potentially runs another command with a pipe
+    command = command.replace("&&", "|")
+    command = command.replace("||", "|")
+    command = command.replace(";", "|")
+
+    pipes = command.split("|")
+    return all(pipe.strip().split()[0] in READ_ONLY_COMMANDS for pipe in pipes)
+
+
+def execute(command: str, explanation: str, yolo_mode: bool = False) -> str:
+    command = command.strip()
+    requires_confirmation = not yolo_mode and not is_read_only_command(command)
+    if requires_confirmation:
+        console.print()
+        console.print(Markdown(f"```shell\n{command}\n```"))
+        if explanation:
+            console.print(f"Explanation: {explanation}")
+        answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
+        if answer not in ("yes", "y", ""):
+            reason = console.input("Why not? (optional, press Enter to skip): ").strip()
+            return f"User declined: {reason or 'no reason'}"
+        console.print(" └ Running...")
+    else:
+        console.print(f" └ Running [bold]{command}[/] (Explanation: {explanation})")
+
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+        )
+    except Exception as e:
+        console.print("   [red]subprocess.run failed[/red]")
+        console.print(f"   [red]{str(e).strip()}[/red]")
+        return f"subprocess.run failed: {str(e).strip()}"
+
+    out = result.stdout
+    err = result.stderr.strip()
+    if result.returncode == 0:
+        console.print("   [green]Command succeeded[/green]")
+    else:
+        console.print(f"   [red]Command failed[/red] (code {result.returncode})")
+        if err:
+            console.print(f"   [red]{err}[/red]")
+
+    if len(out.split("\n")) > 1000:
+        out_first_1000 = "\n".join(out.split("\n")[:1000])
+        out = f"{out_first_1000}... (Truncated)"
+
+    if len(err.split("\n")) > 1000:
+        err_first_1000 = "\n".join(err.split("\n")[:1000])
+        err = f"{err_first_1000}... (Truncated)"
+
+    if len(out) > 20000:
+        out = f"{out[:20000]}... (Truncated)"
+
+    if len(err) > 20000:
+        err = f"{err[:20000]}... (Truncated)"
+
+    return f"Command output (exit {result.returncode}):\n{out}\n{err}"

src/tools/read_file.py

@@ -0,0 +1,61 @@
+from src.constants import console
+
+READ_FILE_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "read_file",
+        "description": "Read a file's contents (the first 1000 lines by default). When reading a file for the first time, do not change the defaults and always read the first 1000 lines unless you are absolutely certain of which lines need to be read.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Relative path of the file",
+                },
+                "start": {
+                    "type": "integer",
+                    "description": "Which line to start reading from",
+                    "default": 1,
+                },
+                "num_lines": {
+                    "type": "integer",
+                    "description": "Number of lines to read, defaults to 1000",
+                    "default": 1000,
+                },
+            },
+            "required": ["path"],
+            "$schema": "http://json-schema.org/draft-07/schema#",
+        },
+    },
+}
+
+
+def read_file(path: str, start: int = 1, num_lines: int = 1000, yolo_mode: bool = False) -> str:
+    if start == 1 and num_lines == 1000:
+        console.print(f" └ Reading file [bold]{path}[/]...")
+    else:
+        last_line = start + num_lines - 1
+        console.print(f" └ Reading file [bold]{path}[/] (lines {start}-{last_line})...")
+
+    try:
+        with open(path) as f:
+            lines = []
+            line_num = 1
+            for line in f:
+                if line_num < start:
+                    line_num += 1
+                    continue
+
+                lines.append(line)
+                line_num += 1
+
+                if len(lines) >= num_lines:
+                    lines.append("... (truncated)")
+                    break
+
+            console.print("   [green]Command succeeded[/green]")
+            return "\n".join(lines)
+    except Exception as e:
+        console.print("   [red]read_file failed[/red]")
+        console.print(f"   [red]{str(e).strip()}[/red]")
+        return f"read_file failed: {e}"

src/utils.py

@@ -1,37 +1,13 @@
 from prompt_toolkit.completion import (
+    CompleteEvent,
     Completer,
     Completion,
-    CompleteEvent,
 )
 from prompt_toolkit.document import Document
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.keys import Keys
 
-from src.constants import (
-    READ_ONLY_COMMANDS,
-    cwd_path,
-)
-
-def is_read_only_command(command: str) -> bool:
-    """A simple check to see if the command is only for reading files.
-
-    Not a comprehensive or foolproof check by any means, and will
-    return false negatives to be safe.
-    """
-    if ">" in command:
-        return False
-
-    # Replace everything that potentially runs another command with a pipe
-    command = command.replace("&&", "|")
-    command = command.replace("||", "|")
-    command = command.replace(";", "|")
-
-    pipes = command.split("|")
-    for pipe in pipes:
-        if pipe.strip().split()[0] not in READ_ONLY_COMMANDS:
-            return False
-
-    return True
+from src.constants import CWD_PATH
 
 
 class FileCompleter(Completer):
@@ -47,13 +23,13 @@ class FileCompleter(Completer):
 
         text_after_at = text[last_at_pos + 1 : cursor_pos]
 
-        base_dir = cwd_path
+        base_dir = CWD_PATH
         search_pattern = text_after_at
         prefix = ""
 
         if "/" in text_after_at:
             dir_part, file_part = text_after_at.rsplit("/", 1)
-            base_dir = cwd_path / dir_part
+            base_dir = CWD_PATH / dir_part
             search_pattern = file_part
             prefix = dir_part + "/"
 

{tass-0.1.11.dist-info → tass-0.1.13.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,15 @@
+src/__init__.py,sha256=tu2q9W5_pkq30l3tRMTGahColBAAubbLP6LaB3l3IFg,89
+src/app.py,sha256=S5-4L4zK09v2wypcbycChlRDLjvd_JG4pLNUyaonrOg,10379
+src/cli.py,sha256=uFt8UJVfQWqMo0UVf2j8ecdZc-rTsHZuU_zh7BM-A1w,663
+src/constants.py,sha256=Gowy-jdKCDUJxZMf8uANCPkmzB5nl3Dl_CWv52E-3Aw,2592
+src/llm_client.py,sha256=bD59tT9EQvF6UuYbMLwFZZwj1iOXtVxRoQZMttWKnlQ,1264
+src/utils.py,sha256=UB9B03aGv9MmtTfDzMmBBrAlaEnmeLmNHeSWqkGoWsU,2401
+src/tools/__init__.py,sha256=5XmZH5XrwRju52BaI_fG7jl2Jllx7C5mr7wsX2Q46DE,269
+src/tools/edit_file.py,sha256=UNuWPdhfw4xJ7grQbHmyYhYBfsxUDlvK45bnCycJs68,6372
+src/tools/execute.py,sha256=3ljDYhL4ogzy89TGvM-XKLaW-fIEUmyr8WTBAyFk8Yk,3685
+src/tools/read_file.py,sha256=LTbchpwP07-QCJOd-cItxgiEWx0tOBWYup8Uf0pc8FA,2171
+tass-0.1.13.dist-info/METADATA,sha256=Fe7PBKpjdtNJyH-sFKZE_eB0tq7_SskwIFHugsLIa3U,2152
+tass-0.1.13.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tass-0.1.13.dist-info/entry_points.txt,sha256=pviKuIOuHvaQ7_YiFxatJEY8XYfh3EzVWy4LJh0v-A0,38
+tass-0.1.13.dist-info/licenses/LICENSE,sha256=Cdr-_YJHgGaf2vJjcoOsRJySkDaogUhu3yIDvpz7GEQ,1066
+tass-0.1.13.dist-info/RECORD,,

tass-0.1.11.dist-info/RECORD

@@ -1,10 +0,0 @@
-src/__init__.py,sha256=tu2q9W5_pkq30l3tRMTGahColBAAubbLP6LaB3l3IFg,89
-src/app.py,sha256=4rdWfwRpjBR_nYE674WktiJq_kzHivlES5-G7D6qk6U,16421
-src/cli.py,sha256=op3fYcyfek_KqCCiA-Zdlc9jVZSCi036whMmR2ZjjAs,76
-src/constants.py,sha256=LYNON4xoqCssh4wA7rjkjyY2JhDXUPFmkQlTz_N0oz8,5089
-src/utils.py,sha256=Uoi60eko9ivvnF-se68yAuwUDFEOHb9Y2SepDaOAbTU,3069
-tass-0.1.11.dist-info/METADATA,sha256=soHqn90KislDBTSa1QQraCJ6gJN2q6kElgMo6VJPgX4,1717
-tass-0.1.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tass-0.1.11.dist-info/entry_points.txt,sha256=pviKuIOuHvaQ7_YiFxatJEY8XYfh3EzVWy4LJh0v-A0,38
-tass-0.1.11.dist-info/licenses/LICENSE,sha256=Cdr-_YJHgGaf2vJjcoOsRJySkDaogUhu3yIDvpz7GEQ,1066
-tass-0.1.11.dist-info/RECORD,,