bat-cli 0.1.0__py3-none-any.whl

create/agent.py

@@ -0,0 +1,312 @@
+import re
+from pathlib import Path
+from typing import Literal
+
+
+BAT_ADK_VERSION = "2026.4.23"
+
+TEMPLATES_DIR = Path(__file__).resolve().parent / "templates" / "agent"
+_DYNAMIC_TEMPLATE_FILES = {
+    ".env.template",
+    "agent.json.template",
+    "agent.spec",
+    "Dockerfile",
+    "Makefile",
+    "llm_client.py.template",
+    "pyproject.toml.template",
+    "src/graph.py",
+}
+
+
+def _load_static_templates() -> dict[str, str]:
+    templates: dict[str, str] = {}
+    for template_path in sorted(TEMPLATES_DIR.rglob("*")):
+        if not template_path.is_file():
+            continue
+
+        relative_path = template_path.relative_to(TEMPLATES_DIR).as_posix()
+        if (
+            relative_path in _DYNAMIC_TEMPLATE_FILES
+            or "__pycache__" in template_path.parts
+            or template_path.suffix == ".pyc"
+        ):
+            continue
+
+        templates[relative_path] = template_path.read_text(encoding="utf-8")
+
+    return templates
+
+
+def _render_template(template_file: str, replacements: dict[str, str]) -> str:
+    template_path = TEMPLATES_DIR / template_file
+    if not template_path.exists():
+        raise FileNotFoundError(f"Template file not found: {template_path}")
+
+    rendered = template_path.read_text(encoding="utf-8")
+    for key, value in replacements.items():
+        rendered = rendered.replace(f"__{key}__", value)
+
+    return rendered
+
+
+def _normalize_name(raw: str, style: Literal["project", "snake", "pascal"]) -> str:
+    if style == "pascal":
+        name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", raw)
+        name = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+        name = re.sub(r"[^A-Za-z0-9]+", "_", name)
+        name = re.sub(r"_+", "_", name).strip("_")
+        parts = [part for part in name.split("_") if part]
+        if parts and parts[-1].lower() == "agent":
+            parts = parts[:-1]
+        if not parts:
+            return ""
+        return "".join(part[:1].upper() + part[1:] for part in parts)
+
+    separator = "-" if style == "project" else "_"
+    name = re.sub(r"([A-Z]+)([A-Z][a-z])", rf"\1{separator}\2", raw)
+    name = re.sub(r"([a-z0-9])([A-Z])", rf"\1{separator}\2", name)
+    name = re.sub(r"[^A-Za-z0-9]+", separator, name)
+    collapsed_separator = re.escape(separator)
+    name = re.sub(rf"{collapsed_separator}+", separator, name).strip(separator)
+
+    if style == "project":
+        project_name = (name or "agent").lower()
+        if project_name.endswith("-agent"):
+            project_name = project_name[: -len("-agent")]
+        return project_name or "agent"
+    return name.lower()
+
+
+def _build_pyproject_content(agent_dir_name: str) -> str:
+    project_name = _normalize_name(agent_dir_name, "project")
+    return _render_template(
+        "pyproject.toml.template",
+        {
+            "BAT_ADK_VERSION": BAT_ADK_VERSION,
+            "PROJECT_DESCRIPTION": f"{project_name.upper()} Agent",
+            "PROJECT_NAME": project_name,
+        },
+    )
+
+
+def _build_agent_spec_content(agent_dir_name: str) -> str:
+    return _render_template(
+        "agent.spec",
+        {
+            "PROJECT_NAME": _normalize_name(agent_dir_name, "project"),
+        },
+    )
+
+
+def _build_dockerfile_content(agent_dir_name: str) -> str:
+    return _render_template(
+        "Dockerfile",
+        {
+            "PROJECT_NAME": _normalize_name(agent_dir_name, "project"),
+        },
+    )
+
+
+def _build_makefile_content(agent_dir_name: str) -> str:
+    return _render_template(
+        "Makefile",
+        {
+            "PROJECT_NAME": _normalize_name(agent_dir_name, "project"),
+        },
+    )
+
+
+def _build_graph_content(agent_dir_name: str, clients: list[str] | None) -> str:
+    resolved_clients = _resolve_client_specs(clients)
+    agent_class_name = _normalize_name(agent_dir_name, "pascal") or "Agent"
+
+    client_imports = "\n".join(
+        f"from .llm_clients.{file_stem} import {class_name}"
+        for file_stem, class_name in resolved_clients
+    )
+
+    setup_blocks: list[str] = []
+
+    for file_stem, class_name in resolved_clients:
+        
+        setup_blocks.append(
+            "\n".join(
+                [
+                    f"        self.{file_stem} = {class_name}(",
+                    "            tools=[],",
+                    "        )",
+                ]
+            )
+        )
+
+    return _render_template(
+        "src/graph.py",
+        {
+            "AGENT_CLASS_NAME": agent_class_name,
+            "CLIENT_IMPORTS": client_imports,
+            "CLIENT_SETUP": "\n\n".join(setup_blocks),
+        },
+    )
+
+
+def _build_agent_json_content(agent_dir_name: str) -> str:
+    return _render_template(
+        "agent.json.template",
+        {
+            "AGENT_NAME": agent_dir_name,
+        },
+    )
+
+
+def _build_env_template_content(
+    *,
+    port: int,
+    model: str,
+    model_provider: str,
+) -> str:
+    return _render_template(
+        ".env.template",
+        {
+            "PORT": str(port),
+            "MODEL": model,
+            "MODEL_PROVIDER": model_provider,
+        },
+    )
+
+
+def _build_llm_client_content(class_name: str) -> str:
+    return _render_template(
+        "llm_client.py.template",
+        {
+            "CLASS_NAME": class_name,
+        },
+    )
+
+
+def _resolve_client_specs(clients: list[str] | None) -> list[tuple[str, str]]:
+    if not clients:
+        return [("example_client", "ExampleClient")]
+
+    resolved: list[tuple[str, str]] = []
+    seen: set[str] = set()
+
+    for raw_name in clients:
+        snake_name = _normalize_name(raw_name, "snake")
+        if not snake_name:
+            continue
+
+        file_stem = snake_name if snake_name.endswith("_client") else f"{snake_name}_client"
+        if file_stem in seen:
+            continue
+
+        pascal_name = _normalize_name(raw_name, "pascal")
+        if not pascal_name:
+            continue
+        class_name = pascal_name if pascal_name.endswith("Client") else f"{pascal_name}Client"
+
+        seen.add(file_stem)
+        resolved.append((file_stem, class_name))
+
+    return resolved or [("example_client", "ExampleClient")]
+
+
+def _write_llm_clients(
+    llm_clients_dir: Path,
+    *,
+    clients: list[str] | None,
+    force: bool,
+) -> list[Path]:
+    created: list[Path] = []
+    for file_stem, class_name in _resolve_client_specs(clients):
+        client_path = llm_clients_dir / f"{file_stem}.py"
+        if client_path.exists() and not force:
+            continue
+
+        client_path.parent.mkdir(parents=True, exist_ok=True)
+        client_path.write_text(_build_llm_client_content(class_name), encoding="utf-8")
+        created.append(client_path)
+
+    return created
+
+
+def create_agent_scaffold(
+    target_dir: Path,
+    *,
+    force: bool = False,
+    clients: list[str] | None = None,
+    port: int = 9900,
+    model: str = "gpt-4o-mini",
+    model_provider: str = "openai",
+) -> list[Path]:
+    if target_dir.exists() and any(target_dir.iterdir()) and not force:
+        raise FileExistsError(
+            f"Target directory '{target_dir}' already exists and is not empty. "
+            "Use --force to overwrite files."
+        )
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    created: list[Path] = []
+    for relative_path, content in _load_static_templates().items():
+        file_path = target_dir / relative_path
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if file_path.exists() and not force:
+            continue
+
+        file_path.write_text(content, encoding="utf-8")
+        created.append(file_path)
+
+    pyproject_path = target_dir / "pyproject.toml"
+    
+    if force or not pyproject_path.exists():
+        pyproject_path.write_text(_build_pyproject_content(target_dir.name), encoding="utf-8")
+        created.append(pyproject_path)
+
+    agent_json_path = target_dir / "agent.json"
+    if force or not agent_json_path.exists():
+        agent_json_path.write_text(_build_agent_json_content(target_dir.name), encoding="utf-8")
+        created.append(agent_json_path)
+
+    env_path = target_dir / ".env"
+    if force or not env_path.exists():
+        env_path.write_text(
+            _build_env_template_content(
+                port=port,
+                model=model,
+                model_provider=model_provider,
+            ),
+            encoding="utf-8",
+        )
+        created.append(env_path)
+
+    agent_spec_path = target_dir / "agent.spec"
+    if force or not agent_spec_path.exists():
+        agent_spec_path.write_text(_build_agent_spec_content(target_dir.name), encoding="utf-8")
+        created.append(agent_spec_path)
+
+    dockerfile_path = target_dir / "Dockerfile"
+    if force or not dockerfile_path.exists():
+        dockerfile_path.write_text(_build_dockerfile_content(target_dir.name), encoding="utf-8")
+        created.append(dockerfile_path)
+
+    makefile_path = target_dir / "Makefile"
+    if force or not makefile_path.exists():
+        makefile_path.write_text(_build_makefile_content(target_dir.name), encoding="utf-8")
+        created.append(makefile_path)
+
+    graph_path = target_dir / "src" / "graph.py"
+    if force or not graph_path.exists():
+        graph_path.write_text(_build_graph_content(target_dir.name, clients), encoding="utf-8")
+        created.append(graph_path)
+
+    created.extend(
+        _write_llm_clients(
+            target_dir / "src" / "llm_clients",
+            clients=clients,
+            force=force,
+        )
+    )
+
+    return created
+

create/templates/agent/.dockerignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.venv/

create/templates/agent/.env.template

@@ -0,0 +1,4 @@
+# Copy this file to .env and customize values for local runs.
+PORT=__PORT__
+MODEL=__MODEL__
+MODEL_PROVIDER=__MODEL_PROVIDER__

create/templates/agent/.python-version

@@ -0,0 +1 @@
+3.12

create/templates/agent/Dockerfile

@@ -0,0 +1,37 @@
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm AS base
+FROM debian:bookworm-slim AS runtime
+
+# Stage 1: Builder
+FROM base AS builder
+
+# Install objdump
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    binutils
+
+# Copy app files
+WORKDIR /app
+COPY . .
+
+# Install dependencies
+RUN uv lock
+RUN uv sync --locked
+
+# Build the binary
+RUN uv add pyinstaller
+RUN uv run pyinstaller agent.spec
+
+# Strip the binary
+RUN strip dist/__PROJECT_NAME__
+
+# Stage 2: Runtime
+FROM runtime
+
+# Copy built binary
+COPY --from=builder /app/dist/__PROJECT_NAME__ /app/
+COPY --from=builder /app/agent.json /app/
+COPY --from=builder /app/config.yaml /app/
+
+# Entrypoint
+WORKDIR /app
+ENTRYPOINT ["./__PROJECT_NAME__"]

create/templates/agent/Makefile

@@ -0,0 +1,34 @@
+KUBE_CONFIG := ~/.kube/config
+DOCKER_REGISTRY ?= INSERT_YOUR_DOCKER_REGISTRY_HERE
+VERSION ?= $(shell git describe --tags --always --abbrev --dirty)
+
+PORT ?= 9900
+REPO ?= YOUR_REPOSITORY/__PROJECT_NAME__
+TAG ?= latest
+IMAGE := $(DOCKER_REGISTRY)/$(REPO):$(TAG)
+
+.PHONY: build run push clean
+
+build:
+	@echo "Building __PROJECT_NAME__ Agent Docker image with tag: $(IMAGE) - Version: $(VERSION)"
+	docker build $(if $(NO_CACHE),--no-cache) \
+		--build-arg VERSION=$(VERSION) \
+		--tag $(IMAGE) .
+	@echo "__PROJECT_NAME__ Agent Docker image built successfully."
+
+run:
+	docker run --rm \
+		-it \
+		--env-file .env \
+		--network host \
+		-p $(PORT):$(PORT) \
+		-v $(KUBE_CONFIG):/root/.kube/config:ro \
+		$(IMAGE)
+
+push:
+	@echo "Pushing __PROJECT_NAME__ Agent Docker image with tag: $(IMAGE)"
+	docker push $(IMAGE)
+	@echo "__PROJECT_NAME__ Agent Docker image pushed successfully."
+
+clean:
+	docker rmi $(IMAGE) || true

create/templates/agent/README.md

@@ -0,0 +1 @@
+# Example BAT Agent

create/templates/agent/__main__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("BAT agent bootstrap")

create/templates/agent/agent.json.template

@@ -0,0 +1,12 @@
+{
+  "name": "__AGENT_NAME__",
+  "description": "",
+  "version": "1.0.0",
+  "capabilities": {
+    "streaming": true,
+    "pushNotifications": false
+  },
+  "defaultInputModes": ["text"],
+  "defaultOutputModes": ["text"],
+  "skills": []
+}

create/templates/agent/agent.spec

@@ -0,0 +1,45 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+datas = [
+	('src', 'src'),
+]
+
+a = Analysis(
+	['__main__.py'],
+	pathex=[],
+	binaries=[],
+	datas=datas,
+	hiddenimports=[
+		'br_rapp_sdk',
+		'br_rapp_sdk.common',
+	],
+	hookspath=[],
+	hooksconfig={},
+	runtime_hooks=[],
+	excludes=[],
+	noarchive=False,
+	optimize=0,
+)
+
+pyz = PYZ(a.pure)
+
+exe = EXE(
+	pyz,
+	a.scripts,
+	a.binaries,
+	a.datas,
+	[],
+	name='__PROJECT_NAME__',
+	debug=False,
+	bootloader_ignore_signals=False,
+	strip=False,
+	upx=True,
+	upx_exclude=[],
+	runtime_tmpdir=None,
+	console=True,
+	disable_windowed_traceback=False,
+	argv_emulation=False,
+	target_arch=None,
+	codesign_identity=None,
+	entitlements_file=None,
+)

create/templates/agent/config.yaml

@@ -0,0 +1 @@
+checkpoints: false

create/templates/agent/llm_client.py.template

@@ -0,0 +1,36 @@
+from bat.chat_model_client import ChatModelClient, ChatModelClientConfig
+from langchain_core.messages import HumanMessage
+
+
+class __CLASS_NAME__(ChatModelClient):
+
+    SYSTEM_INSTRUCTIONS = (
+        "INSERT INSTRUCTIONS HERE"
+    )
+    USER_INSTRUCTIONS = (
+        "USER QUERY: {message}"
+    )
+
+    def __init__(
+        self,
+        tools,
+    ):
+        super().__init__(
+            system_instructions=self.SYSTEM_INSTRUCTIONS,
+            chat_model_config=ChatModelClientConfig.from_env(client_name="__CLASS_NAME__"),
+            tools=tools,
+        )
+
+    def invoke(
+        self,
+        query: str,
+    ) -> str:
+        """Format the query based on what the client needs to do."""
+        input_message = HumanMessage(
+            content=self.USER_INSTRUCTIONS.format(
+                message=query,
+            )
+        )
+        response = super().invoke(input_message)
+        response_content = response.content.strip()
+        return response_content

create/templates/agent/pyproject.toml.template

@@ -0,0 +1,9 @@
+[project]
+name = "__PROJECT_NAME__"
+version = "1.0.0"
+description = "__PROJECT_DESCRIPTION__"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "bat-adk>=__BAT_ADK_VERSION__"
+]

create/templates/agent/src/graph.py

@@ -0,0 +1,50 @@
+from bat.agent import AgentGraph, AgentState, AgentTaskResult, AgentTaskStatus
+from bat.prebuilt import ReActLoop
+from langgraph.graph import START, END
+from typing import Optional, Self
+from typing_extensions import override
+
+__CLIENT_IMPORTS__
+
+
+class __AGENT_CLASS_NAME__AgentState(AgentState):
+    query: str
+    response: Optional[str] = None
+
+    @classmethod
+    @override
+    def from_query(
+        cls,
+        query: str,
+    ) -> Self:
+        return cls(query=query)
+
+    @override
+    def to_task_result(
+        self,
+    ) -> AgentTaskResult:
+        return AgentTaskResult(
+            task_status=(
+                AgentTaskStatus.AGENT_TASK_STATUS_COMPLETED
+                if self.response
+                else AgentTaskStatus.AGENT_TASK_STATUS_WORKING
+            ),
+            content=self.response or "Generating response...",
+        )
+
+
+class __AGENT_CLASS_NAME__AgentGraph(AgentGraph):
+    @override
+    def setup(
+        self,
+        config,
+    ) -> None:
+        #Client setup
+__CLIENT_SETUP__
+
+    # Graph wiring
+    self.graph_builder.add_edge(
+        START,
+        END,
+    )
+

eval/__init__.py

@@ -0,0 +1 @@
+"""Evaluation command package for bat-cli."""