mycode-coding-agent 0.1.0__py3-none-any.whl

mycode/presentation/command_format.py

@@ -0,0 +1,90 @@
+"""Shared text formatting for interactive command output."""
+
+from collections.abc import Iterable
+
+from mycode.application.agent_session import CompactResult, ContextStatus
+from mycode.persistence.session_store import SessionRecord
+from mycode.presentation.commands import COMMAND_SPECS
+
+
+def format_command_help() -> tuple[str, ...]:
+    lines = ["available commands:"]
+    for spec in COMMAND_SPECS:
+        aliases = ""
+        if spec.aliases:
+            aliases = " (alias: " + ", ".join(
+                f"/{alias}" for alias in spec.aliases
+            ) + ")"
+        lines.append(f"{spec.usage}{aliases} - {spec.description}")
+    return tuple(lines)
+
+
+def format_session_list(
+    sessions: Iterable[SessionRecord],
+    *,
+    current_session_id: str,
+) -> tuple[str, ...]:
+    records = tuple(sessions)
+    if not records:
+        return ("sessions in current project:", "(no sessions)")
+    return (
+        "sessions in current project:",
+        *(
+            f"{'*' if session.id == current_session_id else ' '} "
+            f"{session.id}  {session.title}"
+            for session in records
+        ),
+    )
+
+
+def format_context_status(status: ContextStatus) -> tuple[str, ...]:
+    percent = (
+        0.0
+        if status.max_input_tokens < 1
+        else status.estimated_input_tokens / status.max_input_tokens * 100
+    )
+    provider = (
+        "unavailable"
+        if status.last_provider_prompt_tokens is None
+        else f"{status.last_provider_prompt_tokens:,} tokens"
+    )
+    memory = (
+        "memory: none"
+        if status.memory_entry_count == 0
+        else (
+            "memory: "
+            f"{status.memory_entry_count} entries / "
+            f"~{status.memory_estimated_tokens:,} tokens"
+        )
+    )
+    return (
+        "Context",
+        "estimated input: "
+        f"{status.estimated_input_tokens:,} / "
+        f"{status.max_input_tokens:,} tokens ({percent:.1f}%)",
+        f"context window: {status.context_window_tokens:,}",
+        f"reserved output: {status.reserved_output_tokens:,}",
+        f"safety margin: {status.safety_margin_tokens:,}",
+        f"estimate source: {status.estimate_source}",
+        f"last provider prompt: {provider}",
+        "messages: "
+        f"{status.source_message_count} source / "
+        f"{status.model_visible_message_count} model-visible",
+        memory,
+        "compact: "
+        f"{status.compact_status} / "
+        f"{status.compact_covered_message_count} messages covered",
+        "tool results: "
+        f"{status.compressed_tool_result_count} compressed",
+    )
+
+
+def format_compact_result(result: CompactResult) -> str:
+    if result.status == "compacted" and result.before and result.after:
+        return (
+            "compacted: ~"
+            f"{result.before.estimated_input_tokens:,} → ~"
+            f"{result.after.estimated_input_tokens:,} tokens"
+        )
+    reason = "unknown" if result.reason is None else result.reason
+    return f"compact {result.status}: {reason}"

mycode/presentation/commands.py

@@ -0,0 +1,95 @@
+"""Definitions and parsing for MyCode's shared slash commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CommandSpec:
+    """Metadata describing one canonical slash command."""
+
+    name: str
+    aliases: tuple[str, ...]
+    usage: str
+    description: str
+
+
+@dataclass(frozen=True)
+class ParsedCommand:
+    """A recognized command with its whitespace-separated arguments."""
+
+    name: str
+    args: tuple[str, ...] = ()
+
+
+class CommandParseError(ValueError):
+    """Raised when a registered command receives invalid arguments."""
+
+    def __init__(self, command: str, usage: str) -> None:
+        self.command = command
+        self.usage = usage
+        super().__init__(f"Invalid arguments for /{command}; usage: {usage}")
+
+
+COMMAND_SPECS: tuple[CommandSpec, ...] = (
+    CommandSpec("help", (), "/help", "Show available slash commands."),
+    CommandSpec("new", (), "/new", "Start a new session."),
+    CommandSpec(
+        "sessions",
+        (),
+        "/sessions",
+        "List sessions in the current project.",
+    ),
+    CommandSpec("resume", (), "/resume <session_id>", "Resume a session."),
+    CommandSpec("context", (), "/context", "Show current context information."),
+    CommandSpec("compact", (), "/compact", "Compact the current conversation."),
+    CommandSpec(
+        "exit",
+        ("quit",),
+        "/exit",
+        "Exit the current interactive runtime.",
+    ),
+)
+
+_COMMANDS_BY_NAME: dict[str, CommandSpec] = {}
+for _spec in COMMAND_SPECS:
+    _COMMANDS_BY_NAME[_spec.name] = _spec
+    for _alias in _spec.aliases:
+        _COMMANDS_BY_NAME[_alias] = _spec
+
+
+def parse_slash_command(text: str) -> ParsedCommand | None:
+    """Parse a registered slash command, or return ``None`` for normal input.
+
+    Command names and aliases are case-insensitive. Arguments are split on
+    whitespace only; command-specific validation is intentionally limited to
+    the current contract.
+    """
+
+    parts = text.strip().split()
+    if not parts or not parts[0].startswith("/"):
+        return None
+
+    command_token = parts[0][1:].lower()
+    spec = _COMMANDS_BY_NAME.get(command_token)
+    if spec is None:
+        return None
+
+    args = tuple(parts[1:])
+    if spec.name == "resume":
+        if len(args) != 1:
+            raise CommandParseError(spec.name, spec.usage)
+    elif args:
+        raise CommandParseError(spec.name, spec.usage)
+
+    return ParsedCommand(name=spec.name, args=args)
+
+
+__all__ = [
+    "COMMAND_SPECS",
+    "CommandParseError",
+    "CommandSpec",
+    "ParsedCommand",
+    "parse_slash_command",
+]

mycode/presentation/tui/__init__.py

@@ -0,0 +1,6 @@
+"""Textual presentation for the MyCode interactive UI."""
+
+from mycode.presentation.tui.app import MyCodeTuiApp, run_tui
+from mycode.presentation.tui.presenter import TuiPresenter
+
+__all__ = ["MyCodeTuiApp", "TuiPresenter", "run_tui"]