robotcode-plugin 2.5.0__tar.gz → 2.6.0__tar.gz

{robotcode_plugin-2.5.0 → robotcode_plugin-2.6.0}/.gitignore

@@ -331,7 +331,7 @@ output.xml
 bundled/libs
 
 # robotframework
-results/
+/results/
 
 # kilocode
 .kilocode/
@@ -339,3 +339,7 @@ results/
 # .agents
 .agents/
 skills-lock.json
+.claude
+
+# sarif files
+/**/*.sarif.json

{robotcode_plugin-2.5.0 → robotcode_plugin-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-plugin
-Version: 2.5.0
+Version: 2.6.0
 Summary: Some classes for RobotCode plugin management
 Project-URL: Donate, https://opencollective.com/robotcode
 Project-URL: Documentation, https://github.com/robotcodedev/robotcode#readme
@@ -27,6 +27,7 @@ Requires-Python: >=3.10
 Requires-Dist: click>=8.2.0
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: pluggy>=1.0.0
+Requires-Dist: rich>=14.0.0
 Requires-Dist: tomli-w>=1.0.0
 Description-Content-Type: text/markdown
 

{robotcode_plugin-2.5.0 → robotcode_plugin-2.6.0}/pyproject.toml

@@ -31,6 +31,7 @@ dependencies = [
   "pluggy>=1.0.0",
   "tomli_w>=1.0.0",
   "colorama>=0.4.6",
+  "rich>=14.0.0",
 ]
 dynamic = ["version"]
 

{robotcode_plugin-2.5.0 → robotcode_plugin-2.6.0}/src/robotcode/plugin/__init__.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from types import TracebackType
 from typing import (
     IO,
+    TYPE_CHECKING,
     Any,
     AnyStr,
     Callable,
@@ -29,6 +30,9 @@ import tomli_w
 from robotcode.core.utils.dataclasses import as_dict, as_json
 from robotcode.core.utils.path import same_file
 
+if TYPE_CHECKING:
+    from rich.markdown import Markdown
+
 __all__ = [
     "Application",
     "ColoredOutput",
@@ -101,6 +105,101 @@ class ProgressBar(Protocol[T]):
     def __next__(self) -> T: ...
 
 
+_deep_markdown_cls: "Optional[type[Markdown]]" = None
+
+
+def _get_deep_markdown_cls() -> "type[Markdown]":
+    """Return a cached `rich.markdown.Markdown` subclass tuned for our
+    output, building it on first use.
+
+    `rich` (and its `markdown-it-py` dependency) are hard requirements
+    now, so there's no ImportError fallback — but the import is still
+    deferred to first use so the `--version` / `--help` fast paths don't
+    pay for it.
+
+    All customisation lives on the subclass's own `elements` mapping
+    and `__init__`, so we never mutate rich's global `Markdown.elements`
+    ClassVar or the shared element classes — any other `rich.Markdown`
+    user in the process keeps stock behaviour. Built once and cached."""
+    global _deep_markdown_cls
+    if _deep_markdown_cls is not None:
+        return _deep_markdown_cls
+
+    from markdown_it import MarkdownIt
+    from rich.console import Console, ConsoleOptions, RenderResult
+    from rich.markdown import (
+        Heading,
+        Markdown,
+        TableBodyElement,
+        TableDataElement,
+        TableElement,
+        TableHeaderElement,
+        TableRowElement,
+    )
+    from rich.text import Text
+
+    class LeftHeading(Heading):
+        """Left-justify headings instead of rich's default centering."""
+
+        def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+            for result in super().__rich_console__(console, options):
+                cast(Text, result).justify = "left"
+                yield result
+
+    # rich#3027: table rows render with spurious blank lines unless the
+    # table element classes carry `new_line = False`. Subclass rather
+    # than patch the originals so the change is scoped to our renderer.
+    class _Table(TableElement):
+        new_line = False
+
+    class _TableHeader(TableHeaderElement):
+        new_line = False
+
+    class _TableBody(TableBodyElement):
+        new_line = False
+
+    class _TableRow(TableRowElement):
+        new_line = False
+
+    class _TableData(TableDataElement):
+        new_line = False
+
+    class DeepMarkdown(Markdown):
+        """`rich.markdown.Markdown` builds a `MarkdownIt()` whose
+        `maxNesting` defaults to 20 — and every nested ``list +
+        listitem`` eats two of that budget. A workspace-scale
+        `discover all` document with the typical Robot directory layout
+        (`tests/foo/bar/baz/…`) trips the limit around the 8th nested
+        level, and markdown-it-py silently discards the rest of the
+        document — including any footer such as the Statistics block.
+        Re-parse with a much higher limit so arbitrarily deep trees
+        render in full.
+
+        Customised token → element mappings (left-justified headings,
+        blank-line-free tables) are overridden on this subclass's own
+        `elements` map, leaving rich's global ClassVar untouched."""
+
+        elements = {
+            **Markdown.elements,
+            "heading_open": LeftHeading,
+            "table_open": _Table,
+            "thead_open": _TableHeader,
+            "tbody_open": _TableBody,
+            "tr_open": _TableRow,
+            "td_open": _TableData,
+            "th_open": _TableData,
+        }
+
+        def __init__(self, markup: str, **kwargs: Any) -> None:
+            super().__init__(markup, **kwargs)
+            parser = MarkdownIt().enable("strikethrough").enable("table")
+            parser.options.maxNesting = 1000
+            self.parsed = parser.parse(markup)
+
+    _deep_markdown_cls = DeepMarkdown
+    return DeepMarkdown
+
+
 class Application:
     def __init__(self) -> None:
         self.config = CommonConfig()
@@ -115,12 +214,35 @@ class Application:
     def show_diagnostics(self, value: bool) -> None:
         self._show_diagnostics = value
 
+    def color_for(self, file: Optional[IO[Any]] = None, err: bool = False) -> bool:
+        """Resolve the color decision for a specific output destination.
+
+        Honors the explicit ``--color`` / ``--no-color`` choice first, then the
+        ``FORCE_COLOR`` / ``NO_COLOR`` conventions (https://no-color.org/), and
+        finally the TTY status of the relevant stream — which may be stdout,
+        stderr, or an explicit ``file=``.  This matters because stdout and
+        stderr can be redirected independently: piping ``stdout`` into a file
+        should not disable colour on warnings written to ``stderr`` if that
+        is still attached to a terminal.
+        """
+        pref = self.config.colored_output
+        if pref == ColoredOutput.NO:
+            return False
+        if pref == ColoredOutput.YES:
+            return True
+        if os.environ.get("FORCE_COLOR"):
+            return True
+        if os.environ.get("NO_COLOR"):
+            return False
+        stream = file if file is not None else (sys.stderr if err else sys.stdout)
+        isatty = getattr(stream, "isatty", None)
+        return bool(isatty()) if callable(isatty) else False
+
     @property
     def colored(self) -> bool:
-        return self.config.colored_output in [
-            ColoredOutput.AUTO,
-            ColoredOutput.YES,
-        ]
+        """Shortcut for the color decision on stdout — used for branching
+        between rich and plain rendering paths that always target stdout."""
+        return self.color_for()
 
     @property
     def has_rich(self) -> bool:
@@ -139,12 +261,13 @@ class Application:
         err: Optional[bool] = True,
     ) -> None:
         if self.config.verbose:
+            err_resolved = err if err is not None else True
             click.secho(
                 message() if callable(message) else message,
                 file=file,
                 nl=nl if nl is not None else True,
-                err=err if err is not None else True,
-                color=self.colored,
+                err=err_resolved,
+                color=self.color_for(file=file, err=err_resolved),
                 fg="bright_black",
             )
 
@@ -167,7 +290,7 @@ class Application:
             show_percent=show_percent,
             show_pos=show_pos,
             file=sys.stderr,
-            color=self.colored,
+            color=self.color_for(file=sys.stderr),
         )
 
     def warning(
@@ -177,12 +300,13 @@ class Application:
         nl: Optional[bool] = True,
         err: Optional[bool] = True,
     ) -> None:
+        err_resolved = err if err is not None else True
         click.secho(
             f"[ {click.style('WARN', fg='yellow')} ] {message() if callable(message) else message}",
             file=file,
             nl=nl if nl is not None else True,
-            err=err if err is not None else True,
-            color=self.colored,
+            err=err_resolved,
+            color=self.color_for(file=file, err=err_resolved),
             fg="bright_yellow",
         )
 
@@ -193,12 +317,13 @@ class Application:
         nl: Optional[bool] = True,
         err: Optional[bool] = True,
     ) -> None:
+        err_resolved = err if err is not None else True
         click.secho(
             f"[ {click.style('ERROR', fg='red')} ] {message() if callable(message) else message}",
             file=file,
             nl=nl if nl is not None else True,
-            err=err if err is not None else True,
-            color=self.colored,
+            err=err_resolved,
+            color=self.color_for(file=file, err=err_resolved),
         )
 
     def print_data(
@@ -240,21 +365,19 @@ class Application:
                 if format == OutputFormat.JSON_INDENT:
                     format = OutputFormat.JSON
                 console = Console(soft_wrap=True)
-                if self.config.pager:
+                syntax = Syntax(text, format, background_color="default")
+                if self._should_page(lambda: text.count("\n")):
                     with console.pager(styles=True, links=True):
-                        console.print(Syntax(text, format, background_color="default"))
+                        console.print(syntax)
                 else:
-                    console.print(Syntax(text, format, background_color="default"))
+                    console.print(syntax)
 
                 return
             except ImportError:
                 if self.config.colored_output == ColoredOutput.YES:
                     self.warning('Package "rich" is required to use colored output.')
 
-        if self.config.pager:
-            self.echo_via_pager(text)
-        else:
-            self.echo(text)
+        self.echo_via_pager(text)
 
         return
 
@@ -269,55 +392,57 @@ class Application:
             message() if callable(message) else message,
             file=file,
             nl=nl,
-            color=self.colored,
+            color=self.color_for(file=file, err=err),
             err=err,
         )
 
-    def echo_as_markdown(self, text: str) -> None:
-        if self.colored:
-            try:
-                from rich.console import Console, ConsoleOptions, RenderResult
-                from rich.markdown import (
-                    Heading,
-                    Markdown,
-                    TableBodyElement,
-                    TableDataElement,
-                    TableElement,
-                    TableHeaderElement,
-                    TableRowElement,
-                )
-                from rich.text import Text
-
-                # this is needed because of https://github.com/Textualize/rich/issues/3027
-                TableElement.new_line = False
-                TableHeaderElement.new_line = False
-                TableBodyElement.new_line = False
-                TableRowElement.new_line = False
-                TableDataElement.new_line = False
+    def _should_page(self, measure_lines: Callable[[], int]) -> bool:
+        """Tri-state pager decision.
+
+        - `config.pager` is True  → always page.
+        - `config.pager` is False → never page.
+        - `config.pager` is None  → auto: page only when stdout is a TTY AND
+                                     the rendered output exceeds the terminal
+                                     height (measured via the callback).
+        """
+        pref = self.config.pager
+        if pref is True:
+            return True
+        if pref is False:
+            return False
+        if not sys.stdout.isatty():
+            return False
+        try:
+            from shutil import get_terminal_size
 
-                class MyHeading(Heading):
-                    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-                        for result in super().__rich_console__(console, options):
-                            cast(Text, result).justify = "left"
+            term_lines = get_terminal_size(fallback=(80, 24)).lines
+            return measure_lines() > term_lines - 2
+        except Exception:
+            return False
 
-                            yield result
+    def echo_as_markdown(self, text: str) -> None:
+        # Plain / piped output just emits the raw markdown — it's
+        # readable as-is and pastable into PRs, Slack, or an LLM.
+        if not self.colored:
+            self.echo_via_pager(text)
+            return
 
-                Markdown.elements["heading_open"] = MyHeading
+        from rich.console import Console
 
-                markdown = Markdown(text, justify="left", code_theme="default")
+        markdown = _get_deep_markdown_cls()(text, justify="left", code_theme="default")
+        console = Console()
 
-                console = Console()
-                if self.config.pager:
-                    with console.pager(styles=True, links=True):
-                        console.print(markdown)
-                else:
-                    console.print(markdown)
-                return
-            except ImportError:
-                if self.config.colored_output == ColoredOutput.YES:
-                    self.warning('Package "rich" is required to use colored output.')
+        def _measure() -> int:
+            measure = Console(width=console.size.width, record=False, soft_wrap=True)
+            with measure.capture() as cap:
+                measure.print(markdown)
+            return cap.get().count("\n")
 
-        self.echo_via_pager(text)
+        if self._should_page(_measure):
+            with console.pager(styles=True, links=True):
+                console.print(markdown)
+        else:
+            console.print(markdown)
 
     def echo_via_pager(
         self,
@@ -325,18 +450,20 @@ class Application:
         color: Optional[bool] = None,
     ) -> None:
         try:
-            if not self.config.pager:
-                text = (
-                    text_or_generator
-                    if isinstance(text_or_generator, str)
-                    else "".join(text_or_generator() if callable(text_or_generator) else text_or_generator)
-                )
-                click.echo(text, color=color if color is not None else self.colored)
+            text = (
+                text_or_generator
+                if isinstance(text_or_generator, str)
+                else "".join(text_or_generator() if callable(text_or_generator) else text_or_generator)
+            )
+            use_color = color if color is not None else self.colored
+            if self._should_page(lambda: text.count("\n")):
+                if use_color:
+                    # click only sets `LESS=-R` when color=None — set it here so
+                    # less renders ANSI styles instead of showing raw ESC codes.
+                    os.environ.setdefault("LESS", "-R")
+                click.echo_via_pager(text, color=use_color)
             else:
-                click.echo_via_pager(
-                    text_or_generator,
-                    color=color if color is not None else self.colored,
-                )
+                click.echo(text, color=use_color)
         except OSError:
             pass
 

robotcode_plugin-2.6.0/src/robotcode/plugin/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.6.0"

robotcode_plugin-2.6.0/src/robotcode/plugin/_agent_detection.py

@@ -0,0 +1,102 @@
+"""Detect whether the current process runs inside an AI agent session.
+
+There is no agreed-upon standard yet — we check a union of variables
+known to be set by popular tools (Claude Code, Cursor, Copilot CLI,
+OpenCode, Codex, …), plus the proposed generic conventions ``AI_AGENT``
+and ``AGENT``. When any of them is set to a truthy value, callers use
+the result to flip presentation defaults (colour, pager, REPL plain
+backend) so agents get clean stdin/stdout without users having to pass
+``--no-color`` / ``--no-pager`` / ``--plain`` on every invocation.
+
+Override hatches:
+
+- ``ROBOTCODE_FORCE_AI_AGENT=1`` — force the detection on (for testing
+  and for cases where a marker variable isn't recognised yet).
+- ``ROBOTCODE_NO_AI_AGENT=1`` — force the detection off, regardless of
+  any other marker.
+"""
+
+import os
+from typing import Final, Tuple
+
+_AGENT_ENV_VARS: Final[Tuple[str, ...]] = (
+    # Generic / proposed standards
+    "AI_AGENT",
+    "AGENT",
+    # Anthropic
+    "CLAUDECODE",
+    "CLAUDE_CODE",
+    # Cursor
+    "CURSOR_AGENT",
+    "CURSOR_TRACE_ID",
+    # OpenAI Codex (set on every subprocess Codex spawns)
+    "CODEX_CI",
+    "CODEX_THREAD_ID",
+    "CODEX_SANDBOX",  # macOS-Seatbelt only; treated as a secondary signal
+    # Google
+    "GEMINI_CLI",
+    "ANTIGRAVITY_AGENT",
+    # GitHub Copilot — COPILOT_AGENT is set in terminals launched from
+    # VS Code Copilot Chat / agent mode (see microsoft/vscode#311734);
+    # COPILOT_AGENT_SESSION_ID is set on every shell command and MCP
+    # server the standalone Copilot CLI spawns (>= 0.0.429, April 2026).
+    "COPILOT_AGENT",
+    "COPILOT_AGENT_SESSION_ID",
+    # Microsoft VS Code (1.121+): set when a terminal command is launched
+    # by the VS Code agent flow (Copilot Chat) rather than a human.
+    "VSCODE_AGENT",
+    # opencode (sets both OPENCODE and AGENT)
+    "OPENCODE",
+    "OPENCODE_CLIENT",  # legacy / Vercel-detection compat
+    # Misc agents
+    "AUGMENT_AGENT",
+    "CLINE_ACTIVE",
+)
+
+_FORCE_ON_VAR: Final = "ROBOTCODE_FORCE_AI_AGENT"
+_FORCE_OFF_VAR: Final = "ROBOTCODE_NO_AI_AGENT"
+
+
+def _is_active(var: str) -> bool:
+    """A marker var is "active" when it is present in the environment
+    with any value other than the empty string or ``"0"``.
+
+    Different agents put very different things in their marker (``1``,
+    the agent's name, a session id, …), so anything we'd treat as
+    "no, you weren't serious" risks fighting the agent. Only the
+    explicit ``=0`` opt-out and absence count as off.
+    """
+    value = os.environ.get(var)
+    if value is None:
+        return False
+    return value.strip() not in ("", "0")
+
+
+def is_running_in_ai_agent() -> bool:
+    """True when any known agent-marker env var is active.
+
+    `ROBOTCODE_FORCE_AI_AGENT` wins over everything; `ROBOTCODE_NO_AI_AGENT`
+    wins over the tool-specific markers but loses to `ROBOTCODE_FORCE_AI_AGENT`.
+    """
+    if _is_active(_FORCE_ON_VAR):
+        return True
+    if _is_active(_FORCE_OFF_VAR):
+        return False
+    return any(_is_active(var) for var in _AGENT_ENV_VARS)
+
+
+def detected_agent_marker() -> str:
+    """Name of the first active env var, or ``""`` when none is set.
+
+    Returns the override-var name when one of them dictated the result;
+    otherwise the first tool-specific marker found, in the order listed
+    in `_AGENT_ENV_VARS`. For diagnostics / debug logging only.
+    """
+    if _is_active(_FORCE_ON_VAR):
+        return _FORCE_ON_VAR
+    if _is_active(_FORCE_OFF_VAR):
+        return ""
+    for var in _AGENT_ENV_VARS:
+        if _is_active(var):
+            return var
+    return ""

{robotcode_plugin-2.5.0 → robotcode_plugin-2.6.0}/src/robotcode/plugin/click_helper/types.py

@@ -30,7 +30,7 @@ class EnumChoice(click.Choice, Generic[T]):  # type: ignore[type-arg]
         excluded: Optional[Set[T]] = None,
     ) -> None:
         super().__init__(
-            choices if excluded is None else (set(choices).difference(excluded)),
+            choices if excluded is None else [c for c in choices if c not in excluded],
             case_sensitive,
         )
 
@@ -76,7 +76,7 @@ class AddressesPort(NamedTuple):
     port: Optional[int] = None
 
 
-class AddressPortParamType(click.ParamType):
+class AddressPortParamType(click.ParamType):  # type: ignore[type-arg]
     name = "[<address>:]<port>"
 
     def convert(
@@ -113,7 +113,7 @@ class MutuallyExclusiveOption(click.Option):
         self.mutually_exclusive = mutually_exclusive
         help = kwargs.get("help", "")
         if self.mutually_exclusive:
-            ex_str = ", ".join(self.mutually_exclusive)
+            ex_str = ", ".join(sorted(self.mutually_exclusive))
             kwargs["help"] = help + ("\n*NOTE:* This option is mutually exclusive with options: " + ex_str + ".")
         super(MutuallyExclusiveOption, self).__init__(*args, **kwargs)
 

robotcode_plugin-2.5.0/src/robotcode/plugin/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.5.0"