@scemoon/cdh 1.0.0

package/tui/atomic.py

@@ -0,0 +1,37 @@
+import tempfile
+import os
+
+
+class AtomicWriteError(Exception):
+    """An Atomic write failed."""
+
+
+def write(path: str, content: str) -> None:
+    """Write a file in an atomic manner.
+
+    Args:
+        filename: Filename of new file.
+        content: Content to write.
+
+    """
+    path = os.path.abspath(path)
+    dir_name = os.path.dirname(path) or "."
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            delete=False,
+            dir=dir_name,
+            prefix=f".{os.path.basename(path)}_tmp_",
+        ) as temporary_file:
+            temporary_file.write(content)
+            temp_name = temporary_file.name
+    except Exception as error:
+        raise AtomicWriteError(
+            f"Failed to write {path!r}; error creating temporary file: {error}"
+        )
+
+    try:
+        os.replace(temp_name, path)  # Atomic on POSIX and Windows
+    except Exception as error:
+        raise AtomicWriteError(f"Failed to write {path!r}; {error}")

package/tui/cli.py

@@ -0,0 +1,313 @@
+import sys
+
+import click
+from tui.app import A2TUIApp
+from tui.agent_schema import Agent
+
+
+def set_process_title(title: str) -> None:
+    """Set the process title.
+
+    Args:
+        title: Desired title.
+    """
+    try:
+        import setproctitle
+
+        setproctitle.setproctitle(title)
+    except Exception:
+        pass
+
+
+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 tui.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)
+        if "--version" in args or "-v" 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, invoke_without_command=True)
+@click.option("-v", "--version", is_flag=True, help="Show version and exit.")
+@click.pass_context
+def main(ctx, version):
+    """ A2TUI — AI for your terminal."""
+    if version:
+        from tui import get_version
+
+        click.echo(get_version())
+        ctx.exit()
+    # If no command and no version flag, let the default command handling proceed
+    if ctx.invoked_subcommand is None and not version:
+        pass
+
+
+# @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(
+    "--public-url",
+    metavar="URL",
+    default=None,
+    help="Public URL to use in conjunction with --serve",
+)
+@click.option("-s", "--serve", is_flag=True, help="Serve A2TUI as a web application")
+def run(
+    port: int,
+    host: str,
+    serve: bool,
+    project_dir: str = ".",
+    agent: str = "",
+    public_url: str | None = None,
+):
+    """Run A2TUI."""
+
+    check_directory(project_dir)
+
+    app = A2TUIApp(
+        agent_data=None,
+        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,
+            public_url=public_url,
+        )
+        set_process_title("tui --serve")
+        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 A2TUI 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 tui.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/tui",
+        "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,
+        )
+        set_process_title("tui acp --serve")
+        server.serve()
+
+    else:
+        app = A2TUIApp(agent_data=agent_data, project_dir=project_dir)
+        app.run()
+        app.run_on_exit()
+
+    print("")
+    print("[bold magenta]Thanks for trying out A2TUI!")
+    print("Please head to Discussions to share your experiences (good or bad).")
+    print("https://github.com/batrachianai/tui/discussions")
+
+
+@main.command("settings")
+def settings() -> None:
+    """Settings information."""
+    app = A2TUIApp()
+    print(f"{app.settings_path}")
+
+
+@main.command("replay")
+@click.argument("path", metavar="FILE")
+def replay(path: str) -> None:
+    """Replay interaction from a log file.
+
+    This is a debugging aid. You probably won't need it unless you are building an agent.
+
+    Run it in place of a command line to run an ACP agent:
+
+    tui acp "tui replay tui.log"
+
+    This will replay the agents output, and A2TUI will update the conversation as it would a real agent.
+    """
+    import time
+
+    stdout = sys.stdout.buffer
+    with open(path, "rb") as replay_file:
+        for line in replay_file.readlines():
+            sender, space, json_line = line.partition(b" ")
+            if sender == b"[agent]":
+                stdout.write(json_line.strip() + b"\n")
+            time.sleep(0.01)
+            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")
+@click.option(
+    "--public-url",
+    metavar="URL",
+    default=None,
+    help="Public URL for textual_serve Server (e.g. https://example.com)",
+)
+def serve(port: int, host: str, public_url: str | None = None) -> None:
+    """Serve A2TUI as a web application."""
+    from textual_serve.server import Server
+
+    server = Server(
+        sys.argv[0], host=host, port=port,         title="A2TUI", public_url=public_url
+    )
+    set_process_title("tui serve")
+    server.serve()
+
+
+@main.command("about")
+def about() -> None:
+    """Show about information."""
+
+    from tui import about
+
+    app = A2TUIApp()
+
+    print(about.render(app))
+
+
+if __name__ == "__main__":
+    main()

package/tui/code_analyze.py

@@ -0,0 +1,27 @@
+from pygments.util import ClassNotFound
+from pygments.lexers import get_lexer_by_name
+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

package/tui/complete.py

@@ -0,0 +1,38 @@
+from collections import defaultdict
+from typing import Iterable
+
+
+class Complete:
+    """Stores substrings and their potential completions."""
+
+    def __init__(self) -> None:
+        self._words: set[str] = set()
+        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.
+        """
+        self._words.update(words)
+        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]:
+        if word in self._words:
+            return []
+        return sorted(self._word_map.get(word, []), key=len, reverse=True)
+
+
+if __name__ == "__main__":
+    complete = Complete()
+    complete.add_words(["ls", "ls -al", "echo 'hello'"])
+
+    print(complete("l"))
+
+    from rich import print
+
+    print(complete._word_map)

package/tui/constants.py

@@ -0,0 +1,61 @@
+"""
+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."""
+
+SESSION_GRID_PAGE_SIZE: Final[int] = 12
+"""Number of sessions to display per page in the sessions grid."""

package/tui/conversation_markdown.py

@@ -0,0 +1,30 @@
+from typing import Iterable
+
+from textual.widgets import Markdown
+from textual.widgets._markdown import MarkdownBlock
+
+
+from tui.menus import MenuItem
+
+
+class ConversationCodeFence(Markdown.BLOCKS["fence"]):
+
+    def get_block_menu(self) -> Iterable[MenuItem]:
+        yield from ()
+
+    def get_block_content(self, destination: str) -> str | None:
+        if destination == "clipboard":
+            return self._content.plain
+        return self.source
+
+
+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)