batrachian-toad 0.5.22__py3-none-any.whl

toad/danger.py

@@ -0,0 +1,371 @@
+from enum import IntEnum
+from functools import lru_cache
+from pathlib import Path
+from typing import Iterable, NamedTuple, Sequence
+
+from textual.content import Span
+
+
+SAFE_COMMANDS = {
+    # Display & Output
+    "echo",
+    "cat",
+    "less",
+    "more",
+    "head",
+    "tail",
+    "tac",
+    "nl",
+    # File & Directory Information
+    "ls",
+    "tree",
+    "pwd",
+    "file",
+    "stat",
+    "du",
+    "df",
+    # Search & Find
+    "find",
+    "locate",
+    "which",
+    "whereis",
+    "type",
+    "grep",
+    "egrep",
+    "fgrep",
+    # Text Processing (read-only)
+    "wc",
+    "sort",
+    "uniq",
+    "cut",
+    "paste",
+    "column",
+    "tr",
+    "diff",
+    "cmp",
+    "comm",
+    # System Information
+    "whoami",
+    "who",
+    "w",
+    "id",
+    "hostname",
+    "uname",
+    "uptime",
+    "date",
+    "cal",
+    "env",
+    "printenv",
+    # Process Information
+    "ps",
+    "top",
+    "htop",
+    "pgrep",
+    "jobs",
+    "pstree",
+    # Network (read-only operations)
+    "ping",
+    "traceroute",
+    "nslookup",
+    "dig",
+    "host",
+    "netstat",
+    "ss",
+    "ifconfig",
+    "ip",
+    # View compressed files (without extracting)
+    "zcat",
+    "zless",
+    # History & Help
+    "history",
+    "man",
+    "help",
+    "info",
+    "apropos",
+    "whatis",
+    # Comparison & Checksums
+    "md5sum",
+    "sha256sum",
+    "sha1sum",
+    "cksum",
+    "sum",
+    # Other Safe Commands
+    "bc",
+    "expr",
+    "test",
+    "sleep",
+    "true",
+    "false",
+    "yes",
+    "seq",
+    "basename",
+    "dirname",
+    "realpath",
+    "readlink",
+}
+
+UNSAFE_COMMANDS = {
+    # File/Directory Creation
+    "mkdir",
+    "touch",
+    "mktemp",
+    "mkfifo",
+    "mknod",
+    # File/Directory Deletion
+    "rm",
+    "rmdir",
+    "shred",
+    # File/Directory Moving/Copying
+    "mv",
+    "cp",
+    "rsync",
+    "scp",
+    "install",
+    # File Modification/Editing
+    "sed",  # with -i flag
+    "awk",  # can write files
+    "tee",  # writes to files and stdout
+    # Permissions/Ownership
+    "chmod",
+    "chown",
+    "chgrp",
+    "chattr",
+    "setfacl",
+    # Linking
+    "ln",
+    "link",
+    "unlink",
+    # Archive/Compression (extract/compress operations)
+    "tar",
+    "untar",
+    "zip",
+    "unzip",
+    "gzip",
+    "gunzip",
+    "bzip2",
+    "bunzip2",
+    "xz",
+    "unxz",
+    "7z",
+    "rar",
+    "unrar",
+    # Download Tools
+    "wget",
+    "curl",
+    "fetch",
+    "aria2c",
+    # Low-level Disk Operations
+    "dd",
+    "truncate",
+    "fallocate",
+    # File Splitting
+    "split",
+    "csplit",
+    # Synchronization
+    "sync",
+    # System Administration
+    "useradd",
+    "userdel",
+    "usermod",
+    "groupadd",
+    "groupdel",
+    "passwd",
+    "mount",
+    "umount",
+    "mkfs",
+    "fdisk",
+    "parted",
+    "swapon",
+    "swapoff",
+    # Other Potentially Dangerous
+    "patch",
+}
+
+
+COMMAND_SPLIT = {";", "&&", "||", "|"}
+CHANGE_DIRECTORY = {"cd"}
+
+
+class DangerLevel(IntEnum):
+    """The danger level of a command."""
+
+    SAFE = 0  # Command is know to be generally save
+    UNKNOWN = 1  # We don't know about this command
+    DANGEROUS = 2  # Command is potentially dangerous (can modify filesystem)
+    DESTRUCTIVE = 3  # Command is both dangerous and refers outside of project root
+
+
+class CommandAtom(NamedTuple):
+    """A command "atom"."""
+
+    name: str
+    """Name of the command."""
+    level: DangerLevel
+    """Danger level."""
+    path: Path
+    """The path to which this command is expected to apply."""
+    span: tuple[int, int]
+    """Span to highlight error."""
+
+
+@lru_cache(maxsize=1024)
+def detect(
+    project_directory: str,
+    current_working_directory: str,
+    command_line: str,
+    *,
+    danger_style: str = "",
+    destructive_style: str = "$text-error on $error-muted 70%",
+) -> tuple[Sequence[Span], DangerLevel]:
+    """Attempt to detect potentially destructive commands.
+
+    Args:
+        project_directory: Project directory.
+        current_working_directory: Current working directory.
+        command_line: Bash command.
+        danger_style: Style to highlight dangerous commands.
+        destructive_style: Style highlight destructive commands.
+
+    Returns:
+        A tuple of spans to highlight the command, and a `DangerLevel` enumeration.
+    """
+    try:
+        atoms = list(
+            analyze(project_directory, current_working_directory, command_line)
+        )
+    except OSError:
+        return [], DangerLevel.UNKNOWN
+    spans: list[Span] = []
+    for atom in atoms:
+        if atom.level == DangerLevel.DANGEROUS and danger_style:
+            spans.append(Span(*atom.span, danger_style))
+        elif atom.level == DangerLevel.DESTRUCTIVE and destructive_style:
+            spans.append(Span(*atom.span, destructive_style))
+
+    if atoms:
+        danger_level = max(command_atom.level for command_atom in atoms)
+    else:
+        danger_level = DangerLevel.SAFE
+
+    return (spans, danger_level)
+
+
+def analyze(
+    project_directory: str, current_working_directory: str, command_line: str
+) -> Iterable[CommandAtom]:
+    """Analyze a command and generate information about potentially destructive commands.
+
+    Args:
+        project_dir: The project directory.
+        command_line: A bash command line.
+
+    Yields:
+        `CommandAtom` objects.
+    """
+    project_path = Path(project_directory).resolve()
+
+    import bashlex
+    from bashlex import ast
+
+    def recurse_nodes(root_path: Path, nodes: list[ast.node]) -> Iterable[CommandAtom]:
+        for node in nodes:
+            kind: str = node.kind
+
+            if kind == "list":
+                yield from recurse_nodes(root_path, node.parts)
+                return
+
+            if kind == "operator":
+                continue
+
+            level = DangerLevel.UNKNOWN
+
+            if not hasattr(node, "parts"):
+                continue
+
+            if node.parts:
+                command_name = command_line[slice(*node.parts[0].pos)]
+                if command_name in SAFE_COMMANDS:
+                    level = DangerLevel.SAFE
+                elif command_name in UNSAFE_COMMANDS:
+                    level = DangerLevel.DANGEROUS
+                parts = node.parts[1:]
+            else:
+                parts = node.parts
+
+            if not parts:
+                yield CommandAtom(command_name, level, root_path, node.pos)
+                continue
+
+            change_directory = command_name in CHANGE_DIRECTORY
+
+            for command_node in parts:
+                command_word = command_line[slice(*node.pos)]
+
+                if command_node.kind == "redirect":
+                    redirect = command_line[slice(*command_node.output.pos)]
+                    try:
+                        target_path = (
+                            root_path / Path(redirect).expanduser()
+                        ).resolve()
+                    except OSError:
+                        continue
+                    if not target_path.is_relative_to(project_path):
+                        yield CommandAtom(
+                            "redirect",
+                            DangerLevel.DESTRUCTIVE,
+                            target_path,
+                            command_node.pos,
+                        )
+                    continue
+
+                if command_node.kind == "command":
+                    yield from recurse_nodes(root_path, command_node.parts)
+                    continue
+                if command_word.startswith(("-", "+")):
+                    continue
+                word = command_line[slice(*command_node.pos)]
+                if change_directory:
+                    try:
+                        root_path = (root_path / Path(word)).expanduser().resolve()
+                    except OSError:
+                        pass
+                    continue
+
+                try:
+                    target_path = (root_path / Path(word)).expanduser().resolve()
+                except OSError:
+                    continue
+                if level == DangerLevel.DANGEROUS and not target_path.is_relative_to(
+                    project_path
+                ):
+                    # If refers to a path outside of the project, upgrade to destructive
+                    level = DangerLevel.DESTRUCTIVE
+
+                yield CommandAtom(command_word, level, target_path, node.pos)
+
+    current_path = Path(current_working_directory)
+    try:
+        nodes = bashlex.parse(command_line)
+    except Exception:
+        # Failed to parse bash
+        return
+
+    yield from recurse_nodes(current_path, nodes)
+
+
+if __name__ == "__main__":
+    import os
+    from rich import print
+
+    TEST = [
+        "ls;ls",
+        "echo 'hello world'",
+        "rm foo",
+        "rm ../foo",
+        "rm /",
+        "cat foo > ../foo.txt",
+    ]
+
+    for test in TEST:
+        print(repr(test), detect(os.getcwd(), os.getcwd(), test))

toad/data/agents/ampcode.com.toml

@@ -0,0 +1,51 @@
+# Schema defined in agent_schema.py
+# https://github.com/tao12345666333/amp-acp
+
+identity = "ampcode.com"
+name = "Amp (AmpCode)"
+short_name = "amp"
+url = "https://ampcode.com"
+protocol = "acp"
+author_name = "AmpCode"
+author_url = "https://ampcode.com"
+publisher_name = "Will McGugan"
+publisher_url = "https://willmcgugan.github.io/"
+type = "coding"
+description = "Open-source ACP adapter that exposes the Amp CLI to editors such as Zed via the Agent Client Protocol."
+tags = []
+run_command."*" = "npx -y amp-acp"
+
+help = '''
+# Amp (AmpCode)
+
+Amp is a frontier coding agent for your terminal and editor, built by Sourcegraph.
+
+- **Multi-Model** Sonnet, GPT-5, fast models—Amp uses them all, for what each model is best at.
+- **Opinionated** You're always using the good parts of Amp. If we don't use and love a feature, we kill it.
+- **On the Frontier** Amp goes where the models take it. No backcompat, no legacy features.
+- **Threads** You can save and share your interactions with Amp. You wouldn't code without version control, would you?
+
+## Prerequisites
+
+- Node.js 18+ so `npx` can run the adapter
+- Ensure the `AMP_EXECUTABLE` environment variable points at your Amp binary (or place `amp` on `PATH`)
+
+
+---
+
+## ACP adapter for AmpCode
+
+**Repository**: https://github.com/tao12345666333/amp-acp
+'''
+
+[actions."*".install]
+command = "curl -fsSL https://ampcode.com/install.sh | bash && npm install -g amp-acp"
+description = "Install AMP Code"
+
+[actions."*".install_adapter]
+command = "npm install -g amp-acp"
+description = "Install the Amp ACP adapter"
+
+[actions."*".login]
+command = "amp login"
+description = "Login to Amp (run once)"

toad/data/agents/augmentcode.com.toml

@@ -0,0 +1,40 @@
+# Schema defined in agent_schema.py
+# https://github.com/augmentcode/auggie
+
+identity = "augmentcode.com"
+name = "Auggie (Augment Code)"
+short_name = "auggie"
+url = "https://www.augmentcode.com/product/CLI"
+protocol = "acp"
+author_name = "Augment Code"
+author_url = "https://www.augmentcode.com/"
+publisher_name = "Will McGugan"
+publisher_url = "https://willmcgugan.github.io/"
+type = "coding"
+description = "An AI agent that brings Augment Code's power to the terminal with ACP support for Zed, Neovim, and Emacs."
+tags = []
+run_command."*" = "auggie --acp"
+
+help = '''
+# Auggie (Augment Code)
+
+*The agentic CLI that goes where your code does*
+
+## Features
+
+- **Agent Client Protocol (ACP) Support**: Use Auggie in Zed, Neovim, Emacs, and other ACP-compatible editors
+- **Autonomous Code Analysis**: Intelligently explore codebases and build working memory
+- **Multi-Editor Integration**: Seamlessly integrates with your favorite development environment
+
+---
+
+**Documentation**: https://docs.augmentcode.com/cli/setup-auggie/install-auggie-cli
+'''
+
+[actions."*".install]
+command = "npm install -g @augmentcode/auggie"
+description = "Install Auggie CLI (requires Node 22+)"
+
+[actions."*".login]
+command = "auggie login"
+description = "Login it Auggie (run once)"

toad/data/agents/claude.com.toml

@@ -0,0 +1,41 @@
+# Schema defined in agent_schema.py
+# https://www.claude.com/product/claude-code
+
+identity = "claude.com"
+name = "Claude Code"
+short_name = "claude"
+url = "https://www.claude.com/product/claude-code"
+protocol = "acp"
+author_name = "Anthropic"
+author_url = "https://www.anthropic.com/"
+publisher_name = "Will McGugan"
+publisher_url = "https://willmcgugan.github.io/"
+type = "coding"
+description = "Unleash Claude’s raw power directly in your terminal."
+tags = []
+run_command."*" = "claude-code-acp"
+
+help = '''
+# Claude Code
+
+Built for developers
+Unleash Claude’s raw power directly in your terminal.
+Search million-line codebases instantly.
+Turn hours-long workflows into a single command.
+Your tools.
+Your workflow.
+Your codebase, evolving at thought speed.
+
+--- 
+[ACP adapter for Claude Code](https://github.com/zed-industries/claude-code-acp) by Zed Industries.
+
+'''
+
+
+[actions."*".install]
+command = "curl -fsSL https://claude.ai/install.sh | bash &&  npm install -g @zed-industries/claude-code-acp"
+description = "Install Claude Code + ACP adapter"
+
+[actions."*".install_acp]
+command = "npm install -g @zed-industries/claude-code-acp"
+description = "Install ACP adapter"

toad/data/agents/docker.com.toml

@@ -0,0 +1,59 @@
+# Schema defined in agent_schema.py
+# https://github.com/docker/cagent
+
+identity = "docker.com"
+name = "Docker cagent"
+short_name = "cagent"
+url = "https://docs.docker.com/ai/cagent/"
+protocol = "acp"
+author_name = "Docker"
+author_url = "https://www.docker.com/"
+publisher_name = "Will McGugan"
+publisher_url = "https://willmcgugan.github.io/"
+type = "coding"
+description = "Agent Builder and Runtime by Docker Engineering. Build, orchestrate, and share AI agents with MCP and ACP support."
+tags = []
+run_command."*" = "cagent acp"
+recommended = false
+
+help = '''
+# Docker cagent
+
+**Agent Builder and Runtime by Docker Engineering**
+
+Docker cagent lets you build, orchestrate, and share AI agents that work together as a team.
+
+## Key Features
+
+- **Hierarchical Agent System**: Intelligent task delegation between multiple agents
+- **Model Context Protocol (MCP)**: Rich tool ecosystem via MCP integration
+- **Multiple Interfaces**: CLI, TUI, API server, and MCP server modes
+- **Share & Distribute**: Package and share agents to Docker Hub as OCI artifacts
+
+## Agent Client Protocol Support
+
+cagent supports ACP, enabling integration with ACP-compatible editors and development environments.
+
+## Installation
+
+The easiest way to get cagent is to install Docker Desktop version 4.49 or later, which includes cagent.
+
+## Distribution
+
+Agent configurations can be packaged and shared using the `cagent push` command, treating agents as reproducible OCI artifacts.
+
+---
+
+**Documentation**: https://docs.docker.com/ai/cagent/  
+**GitHub**: https://github.com/docker/cagent  
+**Blog Post**: https://www.docker.com/blog/cagent-build-and-distribute-ai-agents-and-workflows/
+'''
+
+welcome = '''
+Say "hello" to CAgent!
+
+'''
+
+[actions."*".install]
+command = "echo 'Install Docker Desktop 4.49+ which includes cagent: https://www.docker.com/products/docker-desktop/'"
+description = "Install Docker Desktop with cagent"

toad/data/agents/geminicli.com.toml

@@ -0,0 +1,28 @@
+# Schema defined in agent_schema.py
+# https://github.com/google-gemini/gemini-cli
+identity = "geminicli.com"
+name = "Gemini CLI"
+short_name = "gemini"
+url = "https://geminicli.com/"
+protocol = "acp"
+author_name = "Google"
+author_url = "https://www.gooogle.com"
+publisher_name = "Will McGugan"
+publisher_url = "https://willmcgugan.github.io/"
+type = "coding"
+description = "Query and edit large codebases, generate apps from images or PDFs, and automate complex workflows—all from your terminal."
+tags = []
+run_command."*" = "gemini --experimental-acp"
+
+help = '''
+# Gemini CLI
+
+**Build  debug & deploy with AI**
+
+Query and edit large codebases, generate apps from images or PDFs, and automate complex workflows—all from your terminal.
+
+'''
+
+[actions."*".install]
+command = "npm install -g @google/gemini-cli"
+description = "Install Gemini CLI"

toad/data/agents/goose.ai.toml

@@ -0,0 +1,51 @@
+# Schema defined in agent_schema.py
+# https://github.com/block/goose
+
+identity = "goose.ai"
+name = "Goose"
+short_name = "goose"
+url = "https://block.github.io/goose/"
+protocol = "acp"
+author_name = "Block"
+author_url = "https://block.xyz/"
+publisher_name = "Will McGugan"
+publisher_url = "https://willmcgugan.github.io/"
+type = "coding"
+description = "An open source, extensible AI agent that goes beyond code suggestions - install, execute, edit, and test with any LLM."
+tags = []
+run_command."*" = "goose acp"
+
+help = '''
+# Goose 🪿
+
+**An open source, extensible AI agent**
+
+Goose is an open framework for AI agents that goes beyond code suggestions to install dependencies, execute commands, edit files, and run tests.
+
+## Key Features
+
+- **Extensible Framework**: Plugin-based architecture for custom tools and behaviors
+- **Multi-LLM Support**: Works with various LLM providers
+- **Agent Client Protocol (ACP)**: Native ACP support for editor integration
+- **Multiple Interfaces**: CLI, and ACP server modes
+
+## Configuration
+
+You can override ACP configurations using environment variables:
+- `GOOSE_PROVIDER`: Set your preferred LLM provider
+- `GOOSE_MODEL`: Specify the model to use
+
+---
+
+**Documentation**: https://block.github.io/goose/docs/guides/acp-clients/  
+**GitHub**: https://github.com/block/goose  
+**Quickstart**: https://block.github.io/goose/docs/quickstart/
+'''
+
+[actions."*".install]
+command = "curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash"
+description = "Install Goose"
+
+[action."*".update]
+command = "Update Goose"
+description = "Update Goose"

toad/data/agents/inference.huggingface.co.toml

@@ -0,0 +1,33 @@
+# Schema defined in agent_schema.py
+
+active = true
+identity = "inference.huggingface.co"
+name = "Hugging Face Inference Providers"
+short_name = "hf"
+url = "https://huggingface.co"
+protocol = "acp"
+author_name = "Hugging Face"
+author_url = "https://huffingface.co"
+publisher_name = "Hugging Face"
+publisher_url = "https://huffingface.co"
+type = "chat"
+description = """
+Chat with the latest open weight models from Hugging Face inference Providers. Create an account at HuggingFace account and register with [b]toad-hf-inference-explorers[/] for [bold $success]$10[/] of free credit!"""
+tags = []
+run_command."*" = "hf-inference-acp -x"
+
+help = '''
+# Hugging Face Inference Providers
+
+Chat with the latest open weight models using Hugging Face inference providers.
+
+--- 
+
+Create an account at huggingface.co/join and register with [Toad Explorers](https://huggingface.co/toad-hf-inference-explorers) for **$10** of free credit!
+'''
+
+recommended = true
+
+[actions."*".install]
+command = "uv tool install -U hf-inference-acp --with-executables-from huggingface_hub --force"
+description = "Install Hugging Face Inference Providers"