Make custom commands tui only as well.

Author: beacoder

README.md

@@ -129,7 +129,9 @@ TUI slash commands: `/plan` `/build` `/init` `/review` `/explain`
 `/restore` `/clear` `/exit` — `/explain [project] [target]` explains
 code and `/summary` appends a conversation summary (both TUI-only);
 `/sessions` lists saved sessions and `/restore [path|title|--latest]`
-restores one (`/restore` matches sessions by title substring).
+restores one (`/restore` matches sessions by title substring). Custom
+commands from `prompts/commands/*.txt` are TUI slash commands too
+(TUI-only — no CLI subcommand is registered for them).
 
 Input editing: type your message, press **Enter** for a new line, and
 **Esc then Enter** (or **Alt+Enter**) to submit. **Up/Down** recall

python_agent_harness/cli.py

@@ -3,10 +3,10 @@
 Commands:
   run [project]            interactive TUI agent session (default)
   config [--init]          show effective LLM config / write a template file
-  <custom>                 any prompt file in prompts/commands/
 
-init, review, sessions, restore (and summary/explain) are TUI slash
-commands only — see the TUI help for /init /review /sessions /restore.
+Custom commands (prompts/commands/*.txt) — like init, review,
+sessions, restore and summary/explain — are TUI slash commands only;
+they are NOT registered as CLI subcommands.
 
 Configuration (LLM etc.) is read from a JSON file, by default
 ~/.config/python-agent-harness/config.json; see `config --init`.
@@ -20,18 +20,10 @@
 
 from . import config
 from .client import Client
-from .commands import (
-    SessionCommand, find_command, load_custom_commands,
-)
 from .agent_session import AgentSession
 from .tools import default_registry
 
 
-# Commands available only as TUI slash commands (e.g. /explain) — they
-# are NOT registered as CLI subcommands.
-TUI_ONLY_COMMANDS = {"explain"}
-
-
 def make_session(
     project_dir: str,
     config_path: str | None = None,
@@ -122,40 +114,6 @@ def cmd_config(args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_custom(args: argparse.Namespace) -> int:
-    cmd = find_command(args.command_name)
-    if cmd is None:
-        print(f"unknown custom command: {args.command_name}", file=sys.stderr)
-        return 1
-    _run_command(cmd, args.project, args.extra, args.config)
-    return 0
-
-
-def _run_command(
-    cmd: SessionCommand,
-    project: str | None,
-    extra: str | None,
-    config_path: str | None = None,
-) -> None:
-    project_dir = project or os.getcwd()
-    session = make_session(project_dir, config_path=config_path)
-    cmd.run(lambda **kw: _adopt(session, kw), project_dir=project_dir, extra=extra)
-
-
-def _adopt(session: AgentSession, kw: dict) -> AgentSession:
-    # SessionCommand.run builds its own session kwargs; reuse ours.
-    # The command's prompt becomes the "actual agent prompt"; the
-    # project context + task-completion rules are kept in front of it.
-    if kw.get("system_prompt") is not None:
-        from .prompts import assemble_agent_prompt
-
-        session.system_prompt = assemble_agent_prompt(
-            session.project_dir, kw["system_prompt"],
-            context_path=getattr(session, "_configured_context_path", None),
-        )
-    return session
-
-
 def _add_config_arg(
     parser: argparse.ArgumentParser, suppress: bool = False
 ) -> None:
@@ -186,15 +144,6 @@ def build_parser() -> argparse.ArgumentParser:
     p_config.add_argument("--force", action="store_true", help="overwrite an existing file")
     p_config.add_argument("--path", metavar="PATH", help="config file path")
     p_config.set_defaults(func=cmd_config)
-
-    for cmd in load_custom_commands():
-        if cmd.name in TUI_ONLY_COMMANDS:
-            continue  # TUI slash command only (e.g. /explain)
-        p = sub.add_parser(cmd.name, help=f"run custom command {cmd.name}")
-        _add_config_arg(p, suppress=True)
-        p.add_argument("project", nargs="?")
-        p.add_argument("extra", nargs="?", help="arguments for the command")
-        p.set_defaults(func=cmd_custom, command_name=cmd.name)
     return parser
 
 
@@ -205,8 +154,6 @@ def main(argv: list[str] | None = None) -> int:
         return cmd_run(args)
     if args.command == "config":
         return cmd_config(args)
-    if hasattr(args, "func"):
-        return args.func(args)
     parser.print_help()
     return 1
 

python_agent_harness/commands.py

@@ -1,8 +1,10 @@
-"""Session commands: init, review, summary, custom commands.
+"""Session commands: init, review, custom commands (TUI slash commands).
 
-Ported from gptel-agent-harness-commands.el.  Each command builds a
-fresh session (buffer) with a prompt file as the system prompt and a
-kickoff message, then runs the agent loop.
+Ported from gptel-agent-harness-commands.el.  Commands run inside the
+current TUI session (tui._run_slash_command): the command's prompt
+file becomes the run's system prompt, the project context and
+task-completion rules stay in front of it, and the kickoff message is
+the run's user text.
 
 Tool availability per command:
 - init/review: all tools EXCEPT PlanExit (they are one-shot runs that
@@ -18,9 +20,7 @@
 from pathlib import Path
 from typing import Any, Callable
 
-from .agent import run_agent_loop
 from .prompts import read_prompt_file
-from .models import Message
 
 PROMPTS_DIR = Path(__file__).parent / "prompts"
 COMMANDS_DIR = PROMPTS_DIR / "commands"
@@ -75,8 +75,8 @@ def prepare(
     ) -> tuple[str, str, str]:
         """Resolve (cwd, system_prompt, kickoff) without creating a session.
 
-        Shared by the CLI (which builds a fresh session) and the TUI
-        slash commands (which run inside the current session).
+        Used by the TUI slash commands, which run inside the current
+        session.
         """
         cwd = project_dir or _project_root(__import__("os").getcwd())
         prompt = _substitute(read_prompt_file(self.prompt_file), cwd, extra)
@@ -85,35 +85,6 @@ def prepare(
             kickoff = kickoff.replace("${path}", cwd)
         return cwd, prompt, kickoff
 
-    def run(
-        self,
-        session_factory,
-        project_dir: str | None = None,
-        extra: str | None = None,
-    ) -> None:
-        """Run the command: create a session and start the agent loop."""
-        cwd, prompt, kickoff = self.prepare(project_dir, extra)
-        session = session_factory(
-            project_dir=cwd, system_prompt=prompt, kickoff=kickoff
-        )
-        # the command prompt is the "actual agent prompt"; the project
-        # context and task-completion rules are kept in front of it
-        from .prompts import assemble_agent_prompt
-
-        context_path = getattr(session, "_configured_context_path", None)
-        system = assemble_agent_prompt(cwd, prompt, context_path=context_path)
-        restore_planexit = hide_planexit(session) if not self.allow_planexit else None
-        try:
-            run_agent_loop(
-                session,
-                messages=[Message(role="user", content=kickoff)],
-                top_level=True,
-                system=system,
-            )
-        finally:
-            if restore_planexit:
-                restore_planexit()
-
 
 def initialize_command() -> SessionCommand:
     return SessionCommand(

tests/test_cli.py

@@ -91,20 +91,24 @@ def test_no_context_dir_no_prefix(self):
         finally:
             session.close()
 
-    def test_explain_not_a_cli_subcommand(self):
-        """explain is a TUI slash command only — no CLI subcommand.
+    def test_custom_commands_not_cli_subcommands(self):
+        """Custom commands (e.g. explain) are TUI slash commands only —
+        no CLI subcommand is registered for any of them.
 
-        It must still resolve as a SessionCommand so the TUI /explain
+        They must still resolve as SessionCommands so the TUI /explain
         keeps working (via commands.find_command).
         """
-        from python_agent_harness.commands import find_command
+        from python_agent_harness.commands import (
+            find_command, load_custom_commands,
+        )
 
         parser = cli.build_parser()
         subparsers = next(
             a for a in parser._actions
             if a.__class__.__name__ == "_SubParsersAction"
         )
-        self.assertNotIn("explain", subparsers.choices)
+        for cmd in load_custom_commands():
+            self.assertNotIn(cmd.name, subparsers.choices)
         self.assertIn("run", subparsers.choices)
         self.assertNotIn("review", subparsers.choices)
         self.assertNotIn("init", subparsers.choices)
@@ -176,40 +180,6 @@ def test_hide_planexit_removes_and_restores(self):
         finally:
             s.close()
 
-    def test_command_run_hides_planexit_for_init(self):
-        """SessionCommand.run hides PlanExit for the whole init run and
-        restores it afterwards (even when the run raises)."""
-        import unittest.mock as mock
-
-        from python_agent_harness.agent_session import AgentSession
-        from python_agent_harness.commands import initialize_command
-        from python_agent_harness.tools import default_registry
-
-        session = AgentSession(
-            project_dir="/tmp", client=object(), model="m",
-            registry=default_registry(),
-        )
-        session.switch_to_plan()  # registers PlanExit
-        try:
-            def _loop(*a, **kw):
-                # PlanExit stays hidden for the whole run (sub-agents
-                # share this registry, so they are covered too)
-                self.assertIsNone(session.registry.get("PlanExit"))
-                raise RuntimeError("boom")
-
-            with mock.patch(
-                "python_agent_harness.commands.run_agent_loop",
-                side_effect=_loop,
-            ):
-                with self.assertRaises(RuntimeError):
-                    initialize_command().run(
-                        lambda **kw: session, project_dir="/tmp"
-                    )
-            # restored even though the run raised
-            self.assertIsNotNone(session.registry.get("PlanExit"))
-        finally:
-            session.close()
-
 
 class TestCliSessionCommands(unittest.TestCase):
     def test_removed_cli_subcommands(self):

tests/test_context_rules.py

@@ -84,39 +84,46 @@ def test_make_session_injects_rules(self):
             finally:
                 s.close()
 
-    def test_adopt_keeps_rules_before_command_prompt(self):
-        """init/review/custom commands: the command prompt is the agent
-        prompt; rules stay in front of it."""
-        from python_agent_harness.cli import _adopt
+    def test_slash_commands_keep_rules_before_command_prompt(self):
+        """/init and custom commands (TUI slash path): the command
+        prompt is the run's system prompt; rules stay in front of it."""
+        import io
 
-        class Stub:
-            project_dir = "/tmp"
+        from rich.console import Console
 
-        s = Stub()
-        _adopt(s, {"system_prompt": "COMMAND PROMPT"})
-        self.assertIn("Task Completion Rules", s.system_prompt)
-        self.assertLess(
-            s.system_prompt.index("Task Completion Rules"),
-            s.system_prompt.index("COMMAND PROMPT"),
+        from python_agent_harness.agent_session import AgentSession
+        from python_agent_harness.client import Client
+        from python_agent_harness.tools import default_registry
+        from python_agent_harness.tui import Tui
+
+        session = AgentSession(
+            project_dir="/tmp", client=Client(
+                base_url="http://127.0.0.1:1/v1", api_key="x", model="m",
+            ),
+            model="m", registry=default_registry(),
         )
+        tui = Tui(
+            session, Console(file=io.StringIO(), width=100, force_terminal=False)
+        )
+        captured = {}
 
-    def test_command_run_loop_system_includes_rules(self):
-        from python_agent_harness.commands import initialize_command
+        def fake_start(text, system=None, restore=None):
+            captured["system"] = system
 
-        with mock.patch("python_agent_harness.commands.run_agent_loop") as m:
-            with tempfile.TemporaryDirectory() as d:
-                cmd = initialize_command()
-                cmd.run(
-                    session_factory=lambda **kw: object(),
-                    project_dir=d,
-                    extra=None,
-                )
-            _, kwargs = m.call_args
-            self.assertIn("Task Completion Rules", kwargs["system"])
+        with mock.patch.object(tui, "_start_agent", side_effect=fake_start):
+            tui._handle_slash("/init")
+            self.assertIn("Task Completion Rules", captured["system"])
+            self.assertLess(
+                captured["system"].index("Task Completion Rules"),
+                captured["system"].index("AGENTS.md"),
+            )
+            tui._handle_slash("/explain client.py")
+            self.assertIn("Task Completion Rules", captured["system"])
             self.assertLess(
-                kwargs["system"].index("Task Completion Rules"),
-                kwargs["system"].index("AGENTS.md"),
+                captured["system"].index("Task Completion Rules"),
+                captured["system"].index("You are a senior engineer"),
             )
+        session.close()
 
     def test_agent_loop_falls_back_to_session_prompt(self):
         """A bare run_agent_loop without a system prompt still uses the