robodog-terminal 0.2.0__tar.gz

robodog_terminal-0.2.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: robodog-terminal
+Version: 0.2.0
+Summary: Agentic coding terminal for the shell (runPixel gateway / OpenAI-compatible / offline backends)
+Author: adourish
+License: MIT
+Project-URL: Homepage, https://github.com/adourish/robodog
+Project-URL: Repository, https://github.com/adourish/robodog.git
+Keywords: agent,coding,terminal,cli,gateway,llm,openrouter
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13
+Requires-Dist: prompt_toolkit>=3
+Requires-Dist: requests>=2.25
+Provides-Extra: yaml
+Requires-Dist: PyYAML>=6; extra == "yaml"
+
+# robodog-terminal
+
+A agentic **agentic coding terminal**: a prompted tool-use loop that
+reads/edits files, runs commands, runs tests, and self-corrects — over pluggable
+LLM backends. Designed to run **leading models on self-hosted gateways**
+(air-gapped, where an agentic coding terminal can't reach), and works equally with
+OpenAI-compatible models or a fully offline mock.
+
+## Install
+```bash
+pip install robodog-terminal          # or: pip install -e robodogcli/robodog
+```
+
+## Run
+```bash
+robodog-terminal --backend openai --model gpt-4o     # live (OpenAI/OpenRouter)
+robodog-terminal --backend gateway                       # enterprise box (the gateway / leading models)
+robodog-terminal --echo                               # offline demo, no keys
+robodog-terminal --backend openai -p "fix x.py and run the tests"   # headless (-p)
+python -m terminal.run_tests                          # 18 test suites
+```
+
+## Features
+Agentic loop with an intent nudge + circuit breaker · tools (read/write/edit/
+multi_edit/bash/run_script/run_tests/glob/grep/list_dir) with read-before-edit,
+post-edit syntax verification and fuzzy edits · foreground + background subagents
+(`/bg /tasks /tail /kill`) · per-prompt checkpoints with `/rewind` · JSONL
+sessions (`/resume`, `--continue`) · plan mode · skills & custom commands
+(`.robodog/`) · `CLAUDE.md`/`ROBODOG.md` hierarchy · a rich + prompt_toolkit TUI
+with an emoji/color status line, clickable file & `file:line` links, multiline
+paste, and mid-turn Ctrl+B backgrounding · headless `-p` (text/json) · `/doctor`.
+
+Benchmarked at **capability parity with a leading agentic coding assistant** across 20 agentic
+scenarios. See `robodogcli/docs/TERMINAL_MODE_PLAN.md` for the full design.

robodog_terminal-0.2.0/TERMINAL_README.md

@@ -0,0 +1,34 @@
+# robodog-terminal
+
+A agentic **agentic coding terminal**: a prompted tool-use loop that
+reads/edits files, runs commands, runs tests, and self-corrects — over pluggable
+LLM backends. Designed to run **leading models on self-hosted gateways**
+(air-gapped, where an agentic coding terminal can't reach), and works equally with
+OpenAI-compatible models or a fully offline mock.
+
+## Install
+```bash
+pip install robodog-terminal          # or: pip install -e robodogcli/robodog
+```
+
+## Run
+```bash
+robodog-terminal --backend openai --model gpt-4o     # live (OpenAI/OpenRouter)
+robodog-terminal --backend gateway                       # enterprise box (the gateway / leading models)
+robodog-terminal --echo                               # offline demo, no keys
+robodog-terminal --backend openai -p "fix x.py and run the tests"   # headless (-p)
+python -m terminal.run_tests                          # 18 test suites
+```
+
+## Features
+Agentic loop with an intent nudge + circuit breaker · tools (read/write/edit/
+multi_edit/bash/run_script/run_tests/glob/grep/list_dir) with read-before-edit,
+post-edit syntax verification and fuzzy edits · foreground + background subagents
+(`/bg /tasks /tail /kill`) · per-prompt checkpoints with `/rewind` · JSONL
+sessions (`/resume`, `--continue`) · plan mode · skills & custom commands
+(`.robodog/`) · `CLAUDE.md`/`ROBODOG.md` hierarchy · a rich + prompt_toolkit TUI
+with an emoji/color status line, clickable file & `file:line` links, multiline
+paste, and mid-turn Ctrl+B backgrounding · headless `-p` (text/json) · `/doctor`.
+
+Benchmarked at **capability parity with a leading agentic coding assistant** across 20 agentic
+scenarios. See `robodogcli/docs/TERMINAL_MODE_PLAN.md` for the full design.

robodog_terminal-0.2.0/pyproject.toml

@@ -0,0 +1,35 @@
+# Standalone distribution for Terminal Mode.
+# Build from this directory (robodogcli/robodog):  python -m build
+# Installs the `terminal` package plus the `robodog-terminal` / `robodogt` commands.
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "robodog-terminal"
+version = "0.2.0"
+description = "Agentic coding terminal for the shell (runPixel gateway / OpenAI-compatible / offline backends)"
+readme = "TERMINAL_README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "adourish" }]
+keywords = ["agent", "coding", "terminal", "cli", "gateway", "llm", "openrouter"]
+dependencies = [
+  "rich>=13",
+  "prompt_toolkit>=3",
+  "requests>=2.25",
+]
+
+[project.optional-dependencies]
+yaml = ["PyYAML>=6"]     # nicer .yaml verification in edits
+
+[project.scripts]
+robodog-terminal = "robodog_terminal.app:main"
+robodogt = "robodog_terminal.app:main"
+
+[project.urls]
+Homepage = "https://github.com/adourish/robodog"
+Repository = "https://github.com/adourish/robodog.git"
+
+[tool.setuptools]
+packages = ["robodog_terminal"]

robodog_terminal-0.2.0/robodog_terminal/__init__.py

@@ -0,0 +1,17 @@
+# file: robodog_terminal/__init__.py
+"""
+Robodog Terminal Mode — an agentic interactive terminal.
+
+Provides an agentic tool-use loop (prompted tool-calling), file editing,
+and shell command execution, on top of pluggable LLM backends (the gateway / echo /
+OpenAI-compatible). See docs/TERMINAL_MODE_PLAN.md.
+"""
+__version__ = "0.2.0"
+from .llm_client import LLMClient, Completion, EchoClient, GatewayClient
+from .tools import ToolRegistry, default_registry
+from .loop import AgentLoop
+
+__all__ = [
+    "LLMClient", "Completion", "EchoClient", "GatewayClient",
+    "ToolRegistry", "default_registry", "AgentLoop",
+]

robodog_terminal-0.2.0/robodog_terminal/__main__.py

@@ -0,0 +1,14 @@
+# file: robodog_terminal/__main__.py
+"""Entry point for `python -m robodog.robodog_terminal`."""
+from __future__ import annotations
+
+try:
+    from .app import main
+except ImportError:  # running the folder directly
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+    from robodog_terminal.app import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

robodog_terminal-0.2.0/robodog_terminal/agents.py

@@ -0,0 +1,159 @@
+# file: robodog_terminal/agents.py
+"""
+Subagents: an `agent` tool the model can call to delegate scoped work to a
+child agent with its OWN context (a modern agentic terminal's Agent/Task tool).
+
+Why this matters on the gateway especially: the parent re-sends its whole transcript
+every iteration, so delegating a search/read-heavy job to a child — whose
+transcript is DISCARDED, with only its final text returned as the tool result —
+keeps the parent's context (and token bill) small.
+
+Phase A (this file): foreground subagents — the child loop runs synchronously
+inside the parent's tool call.
+Phase B (later, needs background.py): background=true + task_output polling.
+
+Depth cap = 1: child registries are built WITHOUT the `agent` tool, so
+subagents cannot spawn subagents.
+"""
+from __future__ import annotations
+
+from typing import Callable, Dict, Optional
+
+from .loop import AgentLoop
+from .tools import Tool, ToolParam, ToolRegistry, default_registry
+
+AGENT_TYPES: Dict[str, dict] = {
+    "explore": {
+        "tools": ["read_file", "glob", "grep", "list_dir"],  # read-only
+        "max_iterations": 10,
+        "note": (
+            "You are a READ-ONLY exploration subagent. Investigate the codebase to "
+            "answer the delegated question. You cannot modify files or run commands. "
+            "Your FINAL message (no tool blocks) must contain your complete findings — "
+            "it is the only thing returned to the caller."
+        ),
+    },
+    "general": {
+        "tools": None,  # all tools (minus `agent` itself)
+        "max_iterations": 25,
+        "note": (
+            "You are a subagent completing a delegated task. Work autonomously until "
+            "done. Your FINAL message (no tool blocks) must summarize what you did and "
+            "the outcome — it is the only thing returned to the caller."
+        ),
+    },
+}
+
+
+def _child_registry(parent: ToolRegistry, agent_type: str) -> ToolRegistry:
+    """Fresh registry for the child: same cwd, filtered tools, never `agent`."""
+    child = default_registry(cwd=str(parent.cwd))
+    allowed = AGENT_TYPES[agent_type]["tools"]
+    child._tools = {
+        name: tool
+        for name, tool in child._tools.items()
+        if name != "agent" and (allowed is None or name in allowed)
+    }
+    return child
+
+
+def register_agent_tool(
+    registry: ToolRegistry,
+    client,
+    on_child_event: Optional[Callable[[str, dict], None]] = None,
+    manager=None,
+) -> None:
+    """
+    Add the `agent` tool to `registry`. `client` is the shared LLMClient
+    (the client layer's semaphore caps the gateway concurrency). `on_child_event`
+    receives the child loop's events for indented rendering. `manager` is an
+    optional BackgroundManager enabling background=true subagents + the
+    task_output tool.
+    """
+
+    def _make_child(agent_type: str, cancel_event=None, events=None):
+        cfg = AGENT_TYPES[agent_type]
+        return AgentLoop(
+            client,
+            _child_registry(registry, agent_type),
+            max_iterations=cfg["max_iterations"],
+            on_event=events or on_child_event or (lambda k, d: None),
+            system_suffix=cfg["note"],
+            cancel_event=cancel_event,
+        )
+
+    def _agent(args: Dict[str, str]) -> str:
+        prompt = args["prompt"]
+        agent_type = (args.get("type") or "general").strip().lower()
+        background = str(args.get("background", "")).lower() in ("1", "true", "yes")
+        if agent_type not in AGENT_TYPES:
+            return (f"ERROR: unknown agent type '{agent_type}'. "
+                    f"Available: {', '.join(AGENT_TYPES)}")
+
+        if background:
+            if manager is None:
+                return ("ERROR: background subagents unavailable (no manager); "
+                        "run in foreground by omitting the background param.")
+
+            def target(task):
+                child = _make_child(
+                    agent_type, cancel_event=task.cancel_event,
+                    events=lambda k, d: task.emit(
+                        f"⚙ {d.get('name', '')} " if k == "tool_start" else "")
+                    if k == "tool_start" else None)
+                res = child.run(prompt)
+                return res.final_text
+
+            bg = manager.spawn("agent", f"{agent_type}: {prompt[:50]}", target)
+            return (f"Started background subagent {bg.id} ({agent_type}). "
+                    f"Continue other work; fetch its result later with "
+                    f'<tool name="task_output"><param name="id">{bg.id}</param></tool>.')
+
+        child = _make_child(agent_type)
+        result = child.run(prompt)
+        return (
+            f"[subagent:{agent_type} finished — {result.iterations} steps, "
+            f"{result.total_tokens} tokens]\n{result.final_text}"
+        )
+
+    registry.register(Tool(
+        name="agent",
+        description=(
+            "Delegate a scoped task to a subagent with its own fresh context. "
+            "Use type=explore for read-only codebase investigation (searching, "
+            "reading, summarizing) and type=general for delegated work that may "
+            "edit files or run commands. The subagent's final message is returned "
+            "to you; its intermediate work is not. Subagents cannot spawn subagents. "
+            "PARALLEL FAN-OUT: to run subagents in parallel, emit SEVERAL agent "
+            "calls (foreground, background NOT set) in ONE response — they run "
+            "concurrently and all results return together in that same turn. "
+            "Do NOT use background=true for parallelism; background is only for "
+            "detaching a long task to poll later with task_output."
+        ),
+        params=[
+            ToolParam("prompt", "Complete, self-contained task description for the subagent."),
+            ToolParam("type", "explore | general (default general).", required=False),
+            ToolParam("background", "true to run concurrently (default false).", required=False),
+        ],
+        handler=_agent,
+        mutating=True,  # general-type children can mutate
+    ))
+
+    if manager is not None:
+        def _task_output(args: Dict[str, str]) -> str:
+            task_id = args["id"].strip()
+            task = manager.get(task_id)
+            if task is None:
+                return f"ERROR: no such task '{task_id}'."
+            if task.status == "running":
+                tail = manager.output(task_id, tail=10)
+                return (f"{task_id} still running ({task.kind}). Recent output:\n{tail}"
+                        if tail.strip() else f"{task_id} still running ({task.kind}).")
+            return f"{task_id} {task.status}.\n{task.result or manager.output(task_id)}"
+
+        registry.register(Tool(
+            name="task_output",
+            description="Get the status/result of a background task or subagent by id.",
+            params=[ToolParam("id", "Task id, e.g. bg1.")],
+            handler=_task_output,
+        ))