@scemoon/cdh 1.0.6 → 1.0.8

package/tui/atomic.py

@@ -1,37 +0,0 @@
-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

@@ -1,313 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,61 +0,0 @@
-"""
-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

@@ -1,30 +0,0 @@
-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)