yycode 0.3.2__py3-none-any.whl

agent/tui/approval.py

@@ -0,0 +1,53 @@
+"""Approval adapter for the terminal UI."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+from agent.approval import ApprovalDecision, ApprovalRequest
+
+
+def approval_id_for_request(request: ApprovalRequest) -> str:
+    """Build the approval identifier used by stream events and the TUI."""
+    target = request.path or request.command
+    return "|".join([request.action, request.tool_name, target])
+
+
+class TuiApprovalAdapter:
+    """Bridge runtime approval callbacks to TUI-driven user decisions."""
+
+    def __init__(self) -> None:
+        self._pending: dict[str, asyncio.Future[ApprovalDecision]] = {}
+
+    async def callback(self, request: ApprovalRequest) -> bool:
+        """Wait for the TUI to approve or deny the request."""
+        return (await self.decide(request)).approved
+
+    async def decide(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Wait for the TUI to return an approval decision."""
+        approval_id = approval_id_for_request(request)
+        future: asyncio.Future[ApprovalDecision] = asyncio.get_running_loop().create_future()
+        self._pending[approval_id] = future
+        try:
+            return await future
+        finally:
+            self._pending.pop(approval_id, None)
+
+    def resolve(self, approval_id: str, approved: bool) -> bool:
+        """Resolve one pending approval request."""
+        future: Optional[asyncio.Future[ApprovalDecision]] = self._pending.get(approval_id)
+        if future is None or future.done():
+            return False
+        future.set_result(ApprovalDecision("approved" if approved else "denied"))
+        return True
+
+    def cancel_pending(self) -> int:
+        """Cancel all pending approvals and return how many were resolved."""
+        count = 0
+        for future in list(self._pending.values()):
+            if future.done():
+                continue
+            future.set_result(ApprovalDecision("cancelled"))
+            count += 1
+        return count

agent/tui/commands/__init__.py

@@ -0,0 +1,6 @@
+"""Built-in TUI commands."""
+
+from .base import CommandResult, TuiCommand
+from .registry import CommandRegistry, ParsedCommand, discover_commands
+
+__all__ = ["CommandRegistry", "CommandResult", "ParsedCommand", "TuiCommand", "discover_commands"]

agent/tui/commands/base.py

@@ -0,0 +1,48 @@
+"""Base types for TUI-only commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal, Protocol
+
+if TYPE_CHECKING:  # pragma: no cover
+    from agent.tui.runner import AgentTuiRunner
+
+    from .registry import CommandRegistry
+
+
+Severity = Literal["information", "warning", "error"]
+
+
+@dataclass(frozen=True)
+class CommandContext:
+    """Execution dependencies passed to TUI commands."""
+
+    runner: "AgentTuiRunner"
+    registry: "CommandRegistry"
+    confirmed: bool = False
+    raw_text: str = ""
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    """Result displayed in the TUI after a command executes."""
+
+    title: str
+    content: str = ""
+    severity: Severity = "information"
+    status: str = "completed"
+    clear_input: bool = True
+
+
+class TuiCommand(Protocol):
+    """Protocol implemented by TUI-only commands."""
+
+    name: str
+    description: str
+    usage: str
+    aliases: tuple[str, ...]
+    destructive: bool
+
+    async def execute(self, ctx: CommandContext, args: str) -> CommandResult:
+        """Execute the command without sending it to the LLM."""

agent/tui/commands/clear.py

@@ -0,0 +1,37 @@
+"""Clear session history command."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .base import CommandContext, CommandResult
+
+
+@dataclass(frozen=True)
+class ClearCommand:
+    name: str = "clear"
+    description: str = "Clear current session message history and TUI timeline"
+    usage: str = ":clear"
+    aliases: tuple[str, ...] = ()
+    destructive: bool = True
+
+    async def execute(self, ctx: CommandContext, args: str) -> CommandResult:
+        if args.strip():
+            return CommandResult(
+                title="Usage: :clear",
+                content="The :clear command does not accept arguments.",
+                severity="warning",
+                status="warning",
+            )
+        if not ctx.confirmed:
+            return CommandResult(
+                title="Confirm clear",
+                content="Clear session history? Type :clear! to confirm.",
+                severity="warning",
+                status="waiting_for_confirmation",
+            )
+        await ctx.runner.clear_session_history()
+        return CommandResult(title="Session cleared", content="Session history cleared.")
+
+
+COMMAND = ClearCommand()

agent/tui/commands/help.py

@@ -0,0 +1,27 @@
+"""Help command for TUI commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from agent.tui.help_content import render_help_page
+
+from .base import CommandContext, CommandResult
+
+
+@dataclass(frozen=True)
+class HelpCommand:
+    name: str = "help"
+    description: str = "List available TUI commands"
+    usage: str = ":help [command]"
+    aliases: tuple[str, ...] = ("?",)
+    destructive: bool = False
+
+    async def execute(self, ctx: CommandContext, args: str) -> CommandResult:
+        return CommandResult(
+            title="yycode Help",
+            content=render_help_page(ctx.registry.list_commands()),
+        )
+
+
+COMMAND = HelpCommand()

agent/tui/commands/registry.py

@@ -0,0 +1,94 @@
+"""Registry and auto-discovery for TUI-only commands."""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from .base import TuiCommand
+
+
+@dataclass(frozen=True)
+class ParsedCommand:
+    """Parsed command line."""
+
+    command: TuiCommand
+    args: str = ""
+    confirmed: bool = False
+    raw_text: str = ""
+
+
+class CommandRegistry:
+    """Lookup table for TUI commands."""
+
+    def __init__(self, commands: Iterable[TuiCommand] = ()) -> None:
+        self._commands: dict[str, TuiCommand] = {}
+        self._aliases: dict[str, TuiCommand] = {}
+        for command in commands:
+            self.register(command)
+
+    def register(self, command: TuiCommand) -> None:
+        """Register one command by its lowercase name and aliases."""
+        name = command.name.strip().lower()
+        if not name:
+            raise ValueError("Command name cannot be empty")
+        if name in self._commands or name in self._aliases:
+            raise ValueError(f"Duplicate TUI command name: {name}")
+        self._commands[name] = command
+        for alias in getattr(command, "aliases", ()) or ():
+            normalized = alias.strip().lower()
+            if not normalized:
+                continue
+            if normalized in self._commands or normalized in self._aliases:
+                raise ValueError(f"Duplicate TUI command alias: {normalized}")
+            self._aliases[normalized] = command
+
+    def get(self, name: str) -> TuiCommand | None:
+        """Return a command by name or alias, if present."""
+        normalized = name.strip().lower().lstrip(":").rstrip("!")
+        return self._commands.get(normalized) or self._aliases.get(normalized)
+
+    def list_commands(self) -> list[TuiCommand]:
+        """Return commands sorted by name."""
+        return [self._commands[name] for name in sorted(self._commands)]
+
+    def matching(self, token: str, limit: int = 8) -> list[TuiCommand]:
+        """Return commands matching a completion token."""
+        normalized = token.strip().lower().lstrip(":")
+        commands = self.list_commands()
+        rows = [command for command in commands if command.name.startswith(normalized)]
+        if normalized and not rows:
+            rows = [command for command in commands if normalized in command.name]
+        return rows[:limit]
+
+    def parse(self, text: str) -> ParsedCommand | None:
+        """Parse a command line such as ':clear!' or ':help clear'."""
+        stripped = text.strip()
+        if not stripped.startswith(":"):
+            return None
+        command_text = stripped[1:].strip()
+        if not command_text:
+            return None
+        name, _, args = command_text.partition(" ")
+        confirmed = name.endswith("!")
+        name = name.rstrip("!")
+        command = self.get(name)
+        if command is None:
+            return None
+        return ParsedCommand(command=command, args=args.strip(), confirmed=confirmed, raw_text=stripped)
+
+
+def discover_commands(package_name: str = "agent.tui.commands") -> CommandRegistry:
+    """Discover COMMAND instances from command modules in this package."""
+    package = importlib.import_module(package_name)
+    registry = CommandRegistry()
+    for module_info in pkgutil.iter_modules(package.__path__):
+        if module_info.name.startswith("_") or module_info.name in {"base", "registry"}:
+            continue
+        module = importlib.import_module(f"{package_name}.{module_info.name}")
+        command = getattr(module, "COMMAND", None)
+        if command is not None:
+            registry.register(command)
+    return registry

agent/tui/help_content.py

@@ -0,0 +1,108 @@
+"""Single-page help content for the TUI :help command."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from agent.tui.commands.base import TuiCommand
+
+
+TUI_SHORTCUTS = [
+    ("Ctrl+Enter / Ctrl+J", "Submit current input"),
+    ("Ctrl+C", "Cancel current task / interrupt"),
+    ("Ctrl+Shift+C", "Copy timeline"),
+    ("Ctrl+L", "Open plain-text timeline"),
+    ("Ctrl+Q", "Quit"),
+    ("Ctrl+T", "Open task plan panel"),
+    ("Ctrl+D", "Open changed files panel"),
+    ("Ctrl+M", "Open message token manager"),
+]
+
+COMPLETION_SHORTCUTS = [
+    ("/", "Open skill completion"),
+    ("@", "Open subagent role completion"),
+    (":", "Open TUI command completion"),
+    ("Up/Down or Ctrl+P/Ctrl+N", "Select completion item"),
+    ("Tab/Enter", "Accept selected completion"),
+    ("Esc", "Close completion or focus input"),
+]
+
+TIMELINE_SHORTCUTS = [
+    ("Up/Down", "Scroll timeline by line"),
+    ("PageUp/PageDown", "Scroll timeline by page"),
+    ("Home/End", "Jump to timeline top/bottom"),
+]
+
+APPROVAL_SHORTCUTS = [
+    ("Y / Enter", "Approve current request"),
+    ("N / Esc", "Deny current request"),
+]
+
+STARTUP_ARGUMENTS = [
+    ("WORKDIR", "Workspace directory. Defaults to the current directory."),
+    ("-d, --debug", "Enable debug logging to console."),
+    ("--log-file", "Write logs to agent_debug.log."),
+    ("-a, --auto", "Auto-approve risky actions where supported."),
+    ("--silent", "Compatibility alias for --auto."),
+    ("-r, --resume ID", "Resume messages from a persisted session id in the same workspace."),
+    ("-s, --sessions", "List persisted sessions for WORKDIR and exit."),
+    ("--list-sessions", "Compatibility alias for --sessions."),
+    ("-t, --temp", "Temporary session; do not save messages."),
+    ("--no-persist", "Compatibility alias for --temp."),
+    ("-x, --delete ID", "Delete a persisted session id for WORKDIR and exit."),
+]
+
+
+def render_help_page(commands: Iterable[TuiCommand]) -> str:
+    """Render the complete single-page TUI help text."""
+    sections = [
+        "yycode Help",
+        "",
+        "TUI Commands",
+        *_render_commands(commands),
+        "",
+        "Keyboard Shortcuts",
+        *_render_rows(TUI_SHORTCUTS),
+        "",
+        "Input Completion",
+        *_render_rows(COMPLETION_SHORTCUTS),
+        "",
+        "Timeline Navigation",
+        *_render_rows(TIMELINE_SHORTCUTS),
+        "",
+        "Approval",
+        *_render_rows(APPROVAL_SHORTCUTS),
+        "",
+        "Subagents",
+        "  Use @role followed by a focused task. Type @ to complete a role.",
+        "  Example: @tester verify the command system behavior",
+        "  Example: @architect /plan design a safer cleanup flow",
+        "",
+        "Skills",
+        "  Use /skill-name followed by the task instruction. Type / to complete a skill.",
+        "  Example: /plan design a command registry",
+        "  Example: /drawio-skill create an architecture diagram",
+        "",
+        "Startup Arguments",
+        "  yycode [WORKDIR] [options]",
+        *_render_rows(STARTUP_ARGUMENTS),
+        "",
+        "More",
+        "  Run `yycode --help` for raw CLI help.",
+    ]
+    return "\n".join(sections)
+
+
+def _render_commands(commands: Iterable[TuiCommand]) -> list[str]:
+    lines: list[str] = []
+    for command in sorted(commands, key=lambda item: item.name):
+        usage = command.usage or f":{command.name}"
+        description = command.description.rstrip(".")
+        lines.append(f"  {usage:<18} {description}.")
+        if command.name == "clear":
+            lines.append("  :clear!            Confirm clearing current session history.")
+    return lines or ["  No TUI commands registered."]
+
+
+def _render_rows(rows: Iterable[tuple[str, str]]) -> list[str]:
+    return [f"  {key:<24} {description}" for key, description in rows]