batrachian-toad 0.5.22__py3-none-any.whl

toad/cli.py

@@ -0,0 +1,257 @@
+import sys
+
+import click
+from toad.app import ToadApp
+from toad.agent_schema import Agent
+
+
+def check_directory(path: str) -> None:
+    """Check a path is directory, or exit the app.
+
+    Args:
+        path: Path to check.
+    """
+    from pathlib import Path
+
+    if not Path(path).resolve().is_dir():
+        print(f"Not a directory: {path}")
+        sys.exit(-1)
+
+
+async def get_agent_data(launch_agent) -> Agent | None:
+    launch_agent = launch_agent.lower()
+
+    from toad.agents import read_agents, AgentReadError
+
+    try:
+        agents = await read_agents()
+    except AgentReadError:
+        agents = {}
+
+    for agent_data in agents.values():
+        if (
+            agent_data["short_name"].lower() == launch_agent
+            or agent_data["identity"].lower() == launch_agent
+        ):
+            launch_agent = agent_data["identity"]
+            break
+
+    return agents.get(launch_agent)
+
+
+class DefaultCommandGroup(click.Group):
+    def parse_args(self, ctx, args):
+        if "--help" in args or "-h" in args:
+            return super().parse_args(ctx, args)
+        # Check if first arg is a known subcommand
+        if not args or args[0] not in self.commands:
+            # If not a subcommand, prepend the default command name
+            args.insert(0, "run")
+        return super().parse_args(ctx, args)
+
+    def format_usage(self, ctx, formatter):
+        formatter.write_usage(ctx.command_path, "[OPTIONS] PATH OR COMMAND [ARGS]...")
+
+
+@click.group(cls=DefaultCommandGroup)
+def main():
+    """🐸 Toad — AI for your terminal."""
+
+
+# @click.group(invoke_without_command=True)
+# @click.pass_context
+@main.command("run")
+@click.argument("project_dir", metavar="PATH", required=False, default=".")
+@click.option("-a", "--agent", metavar="AGENT", default="")
+@click.option(
+    "-p",
+    "--port",
+    metavar="PORT",
+    default=8000,
+    type=int,
+    help="Port to use in conjunction with --serve",
+)
+@click.option(
+    "-H",
+    "--host",
+    metavar="HOST",
+    default="localhost",
+    type=str,
+    help="Host to use in conjunction with --serve",
+)
+@click.option("-s", "--serve", is_flag=True, help="Serve Toad as a web application")
+def run(port: int, host: str, serve: bool, project_dir: str = ".", agent: str = "1"):
+    """Run an installed agent (same as `toad PATH`)."""
+
+    check_directory(project_dir)
+
+    if agent:
+        import asyncio
+
+        agent_data = asyncio.run(get_agent_data(agent))
+    else:
+        agent_data = None
+
+    app = ToadApp(
+        mode=None if agent_data else "store",
+        agent_data=agent_data,
+        project_dir=project_dir,
+    )
+    if serve:
+        import shlex
+        from textual_serve.server import Server
+
+        command_args = sys.argv
+        # Remove serve flag from args (could be either --serve or -s)
+        for flag in ["--serve", "-s"]:
+            try:
+                command_args.remove(flag)
+                break
+            except ValueError:
+                pass
+        serve_command = shlex.join(command_args)
+        server = Server(
+            serve_command,
+            host=host,
+            port=port,
+            title=serve_command,
+        )
+        server.serve()
+    else:
+        app.run()
+    app.run_on_exit()
+
+
+@main.command("acp")
+@click.argument("command", metavar="COMMAND")
+@click.argument("project_dir", metavar="PATH", default=None)
+@click.option(
+    "-t",
+    "--title",
+    metavar="TITLE",
+    help="Optional title to display in the status bar",
+    default=None,
+)
+@click.option("-d", "--project-dir", metavar="PATH", default=None)
+@click.option(
+    "-p",
+    "--port",
+    metavar="PORT",
+    default=8000,
+    type=int,
+    help="Port to use in conjunction with --serve",
+)
+@click.option(
+    "-H",
+    "--host",
+    metavar="HOST",
+    default="localhost",
+    help="Host to use in conjunction with --serve",
+)
+@click.option("-s", "--serve", is_flag=True, help="Serve Toad as a web application")
+def acp(
+    command: str,
+    host: str,
+    port: int,
+    title: str | None,
+    project_dir: str | None,
+    serve: bool = False,
+) -> None:
+    """Run an ACP agent from a command."""
+
+    from rich import print
+
+    from toad.agent_schema import Agent as AgentData
+
+    command_name = command.split(" ", 1)[0].lower()
+    identity = f"{command_name}.custom.batrachian.ai"
+
+    agent_data: AgentData = {
+        "identity": identity,
+        "name": title or command.partition(" ")[0],
+        "short_name": "agent",
+        "url": "https://github.com/batrachianai/toad",
+        "protocol": "acp",
+        "type": "coding",
+        "author_name": "Will McGugan",
+        "author_url": "https://willmcgugan.github.io/",
+        "publisher_name": "Will McGugan",
+        "publisher_url": "https://willmcgugan.github.io/",
+        "description": "Agent launched from CLI",
+        "tags": [],
+        "help": "",
+        "run_command": {"*": command},
+        "actions": {},
+    }
+    if serve:
+        import shlex
+        from textual_serve.server import Server
+
+        command_components = [sys.argv[0], "acp", command]
+        if project_dir:
+            command_components.append(f"--project-dir={project_dir}")
+        serve_command = shlex.join(command_components)
+
+        server = Server(
+            serve_command,
+            host=host,
+            port=port,
+            title=serve_command,
+        )
+        server.serve()
+    else:
+        app = ToadApp(agent_data=agent_data, project_dir=project_dir)
+        app.run()
+        app.run_on_exit()
+
+    print("")
+    print("[bold magenta]Thanks for trying out Toad!")
+    print("Please head to Discussions to share your experiences (good or bad).")
+    print("https://github.com/batrachianai/toad/discussions")
+
+
+@main.command("settings")
+def settings() -> None:
+    """Settings information."""
+    app = ToadApp()
+    print(f"{app.settings_path}")
+
+
+# @main.command("replay")
+# @click.argument("path", metavar="PATH.jsonl")
+# def replay(path: str) -> None:
+#     """Replay interaction from a jsonl file."""
+#     import time
+
+#     stdout = sys.stdout.buffer
+#     with open(path, "rb") as replay_file:
+#         for line in replay_file.readlines():
+#             time.sleep(0.1)
+#             stdout.write(line)
+#             stdout.flush()
+
+
+@main.command("serve")
+@click.option("-p", "--port", metavar="PORT", default=8000, type=int)
+@click.option("-H", "--host", metavar="HOST", default="localhost")
+def serve(port: int, host: str) -> None:
+    """Serve Toad as a web application."""
+    from textual_serve.server import Server
+
+    server = Server(sys.argv[0], host=host, port=port, title="Toad")
+    server.serve()
+
+
+@main.command("about")
+def about() -> None:
+    """Show about information."""
+
+    from toad import about
+
+    app = ToadApp()
+
+    print(about.render(app))
+
+
+if __name__ == "__main__":
+    main()

toad/code_analyze.py

@@ -0,0 +1,28 @@
+from textual.highlight import highlight, guess_language
+from pygments.util import ClassNotFound
+from pygments.lexers import get_lexer_by_name, guess_lexer_for_filename
+from pygments.token import Token
+
+SPECIAL = {Token.Name.Function.Magic, Token.Name.Function, Token.Name.Class}
+
+
+def get_special_name_from_code(code: str, language: str) -> list[str]:
+    try:
+        lexer = get_lexer_by_name(
+            language,
+            stripnl=False,
+            ensurenl=True,
+            tabsize=8,
+        )
+    except ClassNotFound:
+        lexer = get_lexer_by_name(
+            "text",
+            stripnl=False,
+            ensurenl=True,
+            tabsize=8,
+        )
+    special: list[str] = []
+    for token_type, token in lexer.get_tokens(code):
+        if token_type in SPECIAL:
+            special.append(token)
+    return special

toad/complete.py

@@ -0,0 +1,34 @@
+from collections import defaultdict
+from typing import Iterable
+
+
+class Complete:
+    """Stores substrings and their potential completions."""
+
+    def __init__(self) -> None:
+        self._word_map: defaultdict[str, set[str]] = defaultdict(set)
+
+    def add_words(self, words: Iterable[str]) -> None:
+        """Add word(s) word map.
+
+        Args:
+            words: Iterable of words to add.
+        """
+        word_map = self._word_map
+        for word in words:
+            for index in range(1, len(word)):
+                word_map[word[:index]].add(word[index:])
+
+    def __call__(self, word: str) -> list[str]:
+        return sorted(self._word_map.get(word, []), key=len)
+
+
+if __name__ == "__main__":
+    complete = Complete()
+    complete.add_words(["ls", "ls -al", "echo 'hello'"])
+
+    print(complete("l"))
+
+    from rich import print
+
+    print(complete._word_map)

toad/constants.py

@@ -0,0 +1,58 @@
+"""
+This module contains constants, which may be set in environment variables.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Final
+
+get_environ = os.environ.get
+
+
+def _get_environ_bool(name: str, default: bool = False) -> bool:
+    """Check an environment variable switch.
+
+    Args:
+        name: Name of environment variable.
+
+    Returns:
+        `True` if the env var is "1", otherwise `False`.
+    """
+    has_environ = get_environ(name, "1" if default else "0") == "1"
+    return has_environ
+
+
+def _get_environ_int(
+    name: str, default: int, minimum: int | None = None, maximum: int | None = None
+) -> int:
+    """Retrieves an integer environment variable.
+
+    Args:
+        name: Name of environment variable.
+        default: The value to use if the value is not set, or set to something other
+            than a valid integer.
+        minimum: Optional minimum value.
+
+    Returns:
+        The integer associated with the environment variable if it's set to a valid int
+            or the default value otherwise.
+    """
+    try:
+        value = int(os.environ[name])
+    except KeyError:
+        return default
+    except ValueError:
+        return default
+    if minimum is not None:
+        return max(minimum, value)
+    if maximum is not None:
+        return min(maximum, value)
+    return value
+
+
+ACP_INITIALIZE: Final[bool] = _get_environ_bool("TOAD_ACP_INITIALIZE", True)
+"""Initialize ACP agents?"""
+
+DEBUG: Final[bool] = _get_environ_bool("DEBUG", False)
+"""Debug flag."""

toad/conversation_markdown.py

@@ -0,0 +1,19 @@
+from textual.widgets import Markdown
+from textual.widgets._markdown import MarkdownBlock
+from textual.content import Content
+
+
+class ConversationCodeFence(Markdown.BLOCKS["fence"]):
+    pass
+
+
+CUSTOM_BLOCKS = {"fence": ConversationCodeFence}
+
+
+class ConversationMarkdown(Markdown):
+    """Markdown widget with custom blocks."""
+
+    def get_block_class(self, block_name: str) -> type[MarkdownBlock]:
+        if (custom_block := CUSTOM_BLOCKS.get("block_name")) is not None:
+            return custom_block
+        return super().get_block_class(block_name)