robotcode 2.6.2__tar.gz → 2.7.0__tar.gz

{robotcode-2.6.2 → robotcode-2.7.0}/CHANGELOG.md

@@ -2,6 +2,112 @@
 
 All notable changes to this project will be documented in this file. See [conventional commits](https://www.conventionalcommits.org/) for commit guidelines.
 
+## [2.7.0](https://github.com/robotcodedev/robotcode/compare/v2.6.2..v2.7.0) - 2026-07-14
+
+### <!-- 0 -->Features
+
+- **robot:** Make the analysis cache trustworthy under rapid file changes ([c998399](https://github.com/robotcodedev/robotcode/commit/c998399906355535cd3c2d60aaa3c071a37a410e))
+
+  Fast consecutive changes to several files could poison the analysis
+  cache: the editor and the CLI then reported errors that did not exist,
+  like missing keywords or unresolvable variables, until the affected
+  files were touched again. Cached results are now bound to exactly the
+  file state they were computed from, and unsaved editor content is
+  analyzed but never cached, so stale results can no longer stick.
+
+- **robotcode:** Run tests through a wrapper ([7aa84f6](https://github.com/robotcodedev/robotcode/commit/7aa84f6c08d17e95d981e67692763408d66c497c))
+
+  Run the test execution through a command of your choosing, so you can
+  prepare the environment a run needs - start the services, servers,
+  mocks or session the tests depend on, run the tests inside it, and tear
+  it down again afterwards. For anything that is only environment
+  variables, keep using robot.toml's [env].
+
+  Configure it per profile in robot.toml:
+
+      [profiles.integration]
+      wrapper = ["./with-test-services.sh"]
+
+  set it ad hoc with --wrapper (or the ROBOTCODE_WRAPPER env var), and
+  turn a configured wrapper off for one run with --no-wrapper. It applies
+  to every command that executes Robot Framework - run, debug, the REPL
+  and the notebook kernel - never to discovery, the language server or
+  libdoc.
+
+  Editors pick it up automatically because they run robotcode; the
+  VS Code setting robotcode.debug.launchWrapper can override it for the
+  IDE alone.
+
+
+
+### <!-- 1 -->Bug Fixes
+
+- **plugin:** Use compact JSON separators for json output format ([e882368](https://github.com/robotcodedev/robotcode/commit/e882368e52326233100dfe6ddbee3e77c84fbc38))
+
+  The compact flag was compared against OutputFormat.TEXT instead of
+  OutputFormat.JSON, so compact JSON output was never actually applied.
+
+- **robotcode:** Make the wrapper work on Windows ([7baa0ac](https://github.com/robotcodedev/robotcode/commit/7baa0ac9499c406bb47bbb8a16aaa9152bb1ef6f))
+
+  The wrapper re-run used os.execvp to replace the process, which only has
+  POSIX semantics; on Windows os.exec* spawns a new process and exits the
+  caller, so the exit code and stdout/stderr don't propagate. Keep execvp
+  on POSIX (clean, no extra process) and on Windows spawn the command,
+  wait, and forward its exit code. The subprocess tests, and their wrapper
+  scripts, use spawn-and-wait too, so they no longer skip on Windows.
+
+  Also document how running through a wrapper differs on Linux/macOS vs.
+  Windows, and why.
+
+- **robotcode:** Make the wrapper work in VS Code ([1180d9c](https://github.com/robotcodedev/robotcode/commit/1180d9cdc13e7dc313bc26c03c84ba663c8d34c7))
+
+  Running or debugging tests through a wrapper did not work from the
+  editor, where robotcode runs from a bundled path instead of being
+  installed in the interpreter. Two things are fixed:
+
+  - The debug launcher no longer applies the wrapper itself; it forwards a
+    launch.json wrapper to robotcode as --wrapper and lets robotcode apply
+    it (so a launch.json wrapper still overrides the profile's).
+
+  - When robotcode re-executes itself under the wrapper it re-runs through
+    the same entry it was started from (--launcher-script) instead of
+    python -m robotcode.cli, which the bundled interpreter cannot import.
+    ROBOTCODE_BUNDLED_ROBOTCODE_MAIN is deliberately not used for this: VS
+    Code sets it in every terminal, so it would divert a directly started
+    robotcode to the bundled copy.
+
+- **vscode:** Adapt to vscode-languageclient 10 type changes ([95f305a](https://github.com/robotcodedev/robotcode/commit/95f305ae6f402287f2cb0d2ac5028acc4695a69c))
+
+  Bumping vscode-languageclient to 10.1.0 broke the typecheck:
+  LanguageClient now requires a LogOutputChannel instead of a plain
+  OutputChannel, and Diagnostic.message can now be a MarkupContent
+  instead of just a string.
+
+- **vscode:** Restore -I and -N options when running tests ([c76b113](https://github.com/robotcodedev/robotcode/commit/c76b113936599446b9fdae20c6f9441f9a77be43))
+
+  Running a single test, a file, or any subset from the Test Explorer
+  again passes Robot Framework's parse-include (-I) and top-level suite
+  name (-N) options. Since 2.6.0 both were missing, so on Robot Framework
+  6.1+ the run parsed the whole workspace and surfaced parse errors from
+  unrelated files.
+
+  Robot Framework's --parseinclude support is now reported as a
+  per-project fact on the discovery result envelope. In the
+  `robotcode discover -f json` output this is the new
+  `supportsParseInclude` key on the result (replacing the previous
+  `needsParseInclude` key on each item).
+
+
+
+### <!-- 2 -->Documentation
+
+- **news:** Add v2.7.0 release notes ([033e12d](https://github.com/robotcodedev/robotcode/commit/033e12d90d8250513c5805113266996bae512680))
+
+  Announce the test-run wrapper, the trustworthy analysis cache, and the
+  restored -I/-N options for Test Explorer subset runs.
+
+
+
 ## [2.6.2](https://github.com/robotcodedev/robotcode/compare/v2.6.1..v2.6.2) - 2026-06-15
 
 ### <!-- 1 -->Bug Fixes

{robotcode-2.6.2 → robotcode-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode
-Version: 2.6.2
+Version: 2.7.0
 Summary: Command line interface for RobotCode
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -33,35 +33,35 @@ Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE)
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: robotcode-core==2.6.2
-Requires-Dist: robotcode-plugin==2.6.2
-Requires-Dist: robotcode-robot==2.6.2
+Requires-Dist: robotcode-core==2.7.0
+Requires-Dist: robotcode-plugin==2.7.0
+Requires-Dist: robotcode-robot==2.7.0
 Provides-Extra: all
 Requires-Dist: docutils; extra == 'all'
 Requires-Dist: pyyaml>=5.4; extra == 'all'
-Requires-Dist: robotcode-analyze==2.6.2; extra == 'all'
-Requires-Dist: robotcode-debugger==2.6.2; extra == 'all'
-Requires-Dist: robotcode-language-server==2.6.2; extra == 'all'
-Requires-Dist: robotcode-repl-server==2.6.2; extra == 'all'
-Requires-Dist: robotcode-repl==2.6.2; extra == 'all'
-Requires-Dist: robotcode-runner==2.6.2; extra == 'all'
+Requires-Dist: robotcode-analyze==2.7.0; extra == 'all'
+Requires-Dist: robotcode-debugger==2.7.0; extra == 'all'
+Requires-Dist: robotcode-language-server==2.7.0; extra == 'all'
+Requires-Dist: robotcode-repl-server==2.7.0; extra == 'all'
+Requires-Dist: robotcode-repl==2.7.0; extra == 'all'
+Requires-Dist: robotcode-runner==2.7.0; extra == 'all'
 Requires-Dist: robotframework-robocop>=6.0.0; extra == 'all'
 Provides-Extra: analyze
-Requires-Dist: robotcode-analyze==2.6.2; extra == 'analyze'
+Requires-Dist: robotcode-analyze==2.7.0; extra == 'analyze'
 Provides-Extra: debugger
-Requires-Dist: robotcode-debugger==2.6.2; extra == 'debugger'
+Requires-Dist: robotcode-debugger==2.7.0; extra == 'debugger'
 Provides-Extra: languageserver
-Requires-Dist: robotcode-language-server==2.6.2; extra == 'languageserver'
+Requires-Dist: robotcode-language-server==2.7.0; extra == 'languageserver'
 Provides-Extra: lint
 Requires-Dist: robotframework-robocop>=2.0.0; extra == 'lint'
 Provides-Extra: repl
-Requires-Dist: robotcode-repl==2.6.2; extra == 'repl'
+Requires-Dist: robotcode-repl==2.7.0; extra == 'repl'
 Provides-Extra: replserver
-Requires-Dist: robotcode-repl-server==2.6.2; extra == 'replserver'
+Requires-Dist: robotcode-repl-server==2.7.0; extra == 'replserver'
 Provides-Extra: rest
 Requires-Dist: docutils; extra == 'rest'
 Provides-Extra: runner
-Requires-Dist: robotcode-runner==2.6.2; extra == 'runner'
+Requires-Dist: robotcode-runner==2.7.0; extra == 'runner'
 Provides-Extra: yaml
 Requires-Dist: pyyaml>=5.4; extra == 'yaml'
 Description-Content-Type: text/markdown

{robotcode-2.6.2 → robotcode-2.7.0}/pyproject.toml

@@ -48,26 +48,26 @@ classifiers = [
   "Framework :: Robot Framework :: Tool",
 ]
 requires-python = ">=3.10"
-dependencies = ["robotcode-core==2.6.2", "robotcode-plugin==2.6.2", "robotcode-robot==2.6.2"]
+dependencies = ["robotcode-core==2.7.0", "robotcode-plugin==2.7.0", "robotcode-robot==2.7.0"]
 dynamic = ["version"]
 
 [project.optional-dependencies]
-debugger = ["robotcode-debugger==2.6.2"]
-languageserver = ["robotcode-language-server==2.6.2"]
-runner = ["robotcode-runner==2.6.2"]
-analyze = ["robotcode-analyze==2.6.2"]
+debugger = ["robotcode-debugger==2.7.0"]
+languageserver = ["robotcode-language-server==2.7.0"]
+runner = ["robotcode-runner==2.7.0"]
+analyze = ["robotcode-analyze==2.7.0"]
 yaml = ["PyYAML>=5.4"]
 lint = ["robotframework-robocop>=2.0.0"]
 rest = ["docutils"]
-repl = ["robotcode-repl==2.6.2"]
-replserver = ["robotcode-repl-server==2.6.2"]
+repl = ["robotcode-repl==2.7.0"]
+replserver = ["robotcode-repl-server==2.7.0"]
 all = [
-  "robotcode-debugger==2.6.2",
-  "robotcode-language-server==2.6.2",
-  "robotcode-runner==2.6.2",
-  "robotcode-analyze==2.6.2",
-  "robotcode-repl==2.6.2",
-  "robotcode-repl-server==2.6.2",
+  "robotcode-debugger==2.7.0",
+  "robotcode-language-server==2.7.0",
+  "robotcode-runner==2.7.0",
+  "robotcode-analyze==2.7.0",
+  "robotcode-repl==2.7.0",
+  "robotcode-repl-server==2.7.0",
   "PyYAML>=5.4",
   "robotframework-robocop>=6.0.0",
   "docutils"

{robotcode-2.6.2 → robotcode-2.7.0}/src/robotcode/cli/__init__.py

@@ -2,6 +2,9 @@ import json
 import logging
 import logging.config
 import os
+import shlex
+import subprocess
+import sys
 from pathlib import Path
 from typing import Any, List, Literal, Optional
 
@@ -18,6 +21,7 @@ from robotcode.plugin import (
 from robotcode.plugin._agent_detection import is_running_in_ai_agent
 from robotcode.plugin.click_helper.aliases import AliasedGroup
 from robotcode.plugin.click_helper.types import EnumChoice
+from robotcode.plugin.click_helper.wrappable import WRAPPER_APPLIED_ENV, is_wrappable
 from robotcode.plugin.manager import PluginManager
 
 from .__version__ import __version__
@@ -46,6 +50,99 @@ class RobotCodeFormatter(logging.Formatter):
         super().__init__(*args, defaults=defaults, **kwargs)
 
 
+def _maybe_reexec_under_wrapper(
+    ctx: click.Context, app: Application, cli_wrapper: Optional[str] = None, no_wrapper: bool = False
+) -> None:
+    """Re-execute this process through a configured ``wrapper`` command.
+
+    When a ``wrapper`` is configured - either via ``--wrapper`` on the command
+    line (``cli_wrapper``) or the selected profile's ``wrapper`` (e.g. to run
+    the tests inside a specific X11/Wayland session) - and the invoked command
+    is ``@wrappable`` (i.e. it executes Robot Framework), the process
+    re-executes itself **once** through that command before Robot Framework
+    starts. ``--wrapper`` overrides the profile; ``--no-wrapper`` disables
+    wrapping for this run. The guard env var prevents infinite recursion and
+    lets an outer layer suppress the re-exec by setting it itself.
+    """
+    if no_wrapper:
+        if cli_wrapper:
+            app.warning("Ignoring --wrapper because --no-wrapper was given.")
+        return
+    if os.environ.get(WRAPPER_APPLIED_ENV):
+        return
+
+    sub_name = ctx.invoked_subcommand
+    if not sub_name:
+        return
+    # The command itself opts in via @wrappable; aliases resolve to the same
+    # command object, so this is alias-safe and needs no central name list.
+    sub_cmd = ctx.command.get_command(ctx, sub_name) if isinstance(ctx.command, click.Group) else None
+    if sub_cmd is None or not is_wrappable(sub_cmd):
+        if cli_wrapper:
+            app.warning(f"Ignoring --wrapper: '{sub_name}' does not execute Robot Framework.")
+        return
+
+    from robotcode.robot.config.loader import load_robot_config_from_path
+    from robotcode.robot.config.utils import get_config_files
+
+    profile_wrapper = None
+    try:
+        config_files, _, _ = get_config_files(
+            config_files=app.config.config_files,
+            root_folder=app.config.root,
+            no_vcs=app.config.no_vcs,
+            verbose_callback=app.verbose,
+        )
+        # `evaluated_with_env` also applies the profile's `env` to `os.environ`,
+        # so the wrapper command can rely on it.
+        profile = (
+            load_robot_config_from_path(*config_files, verbose_callback=app.verbose)
+            .combine_profiles(*(app.config.profiles or []), verbose_callback=app.verbose, error_callback=app.error)
+            .evaluated_with_env(verbose_callback=app.verbose, error_callback=app.error)
+        )
+        profile_wrapper = profile.wrapper
+    except Exception as e:
+        # Don't fail early on config problems here; the actual command loads the
+        # config again and reports errors properly. An explicit --wrapper is
+        # still honored below.
+        message = str(e)
+        app.verbose(lambda: f"Skipping profile wrapper detection: {message}")
+
+    # `--wrapper` overrides the profile's `wrapper`. The evaluated profile turns
+    # StringExpression entries into plain strings.
+    if cli_wrapper:
+        wrapper = shlex.split(cli_wrapper)
+    elif profile_wrapper:
+        wrapper = [str(w) for w in profile_wrapper]
+    else:
+        return
+
+    # Rebuild the invocation the way this process was actually started, so the
+    # re-exec finds robotcode even when it runs from a bundled path (VS Code) and
+    # is not installed in the interpreter. `launcher_script` is set only when we
+    # were started through a bundled entry (its `__main__` sets it) or an explicit
+    # `--launcher-script`; otherwise robotcode is importable directly and
+    # `-m robotcode.cli` is correct. We deliberately do NOT consult the
+    # ROBOTCODE_BUNDLED_ROBOTCODE_MAIN env var: VS Code sets it in every terminal,
+    # so a directly started robotcode would be diverted to the bundled copy.
+    # Mirrors the debug launcher's `debugger_script` handling.
+    entry = [str(app.config.launcher_script)] if app.config.launcher_script else ["-m", "robotcode.cli"]
+    command = [*wrapper, sys.executable, *entry, *sys.argv[1:]]
+    app.verbose(lambda: "Running under wrapper: " + " ".join(command))
+
+    # Run robotcode again under the wrapper; the guard env stops the spawned
+    # robotcode from wrapping a second time. On POSIX we replace this process with
+    # execvp (no extra process); Windows has no such exec, so there we spawn the
+    # command, wait, and forward its exit code.
+    os.environ[WRAPPER_APPLIED_ENV] = "1"
+    try:
+        if sys.platform == "win32":
+            sys.exit(subprocess.run(command).returncode)
+        os.execvp(command[0], command)
+    except OSError as e:
+        raise click.ClickException(f"Failed to execute wrapper command {wrapper!r}: {e}") from e
+
+
 @click.group(
     cls=AliasedGroup,
     context_settings={"auto_envvar_prefix": "ROBOTCODE"},
@@ -129,6 +226,20 @@ class RobotCodeFormatter(logging.Formatter):
     help="Enables verbose mode.",
     show_envvar=True,
 )
+@click.option(
+    "--wrapper",
+    type=str,
+    default=None,
+    show_envvar=True,
+    help='Command prefix to run the test execution through, e.g. `--wrapper "xvfb-run -a"`. '
+    "Split like a shell command. Applies only to commands that execute Robot Framework "
+    "(run/debug/repl). Overrides the profile's `wrapper`.",
+)
+@click.option(
+    "--no-wrapper",
+    is_flag=True,
+    help="Disable any configured `wrapper` (profile or --wrapper) for this run.",
+)
 @click.option("--log", is_flag=True, help="Enables logging.", show_envvar=True)
 @click.option(
     "--log-level",
@@ -230,7 +341,9 @@ class RobotCodeFormatter(logging.Formatter):
 )
 @click.version_option(version=__version__, prog_name="robotcode")
 @pass_application
+@click.pass_context
 def robotcode(
+    ctx: click.Context,
     app: Application,
     config_files: Optional[List[Path]],
     profiles: Optional[List[str]],
@@ -249,6 +362,8 @@ def robotcode(
     log_calls: bool,
     log_config: Optional[Path],
     default_path: Optional[List[str]],
+    wrapper: Optional[str] = None,
+    no_wrapper: bool = False,
     launcher_script: Optional[str] = None,
     debugpy: bool = False,
     debugpy_port: int = 5678,
@@ -295,6 +410,8 @@ def robotcode(
     app.config.log_level = log_level
     app.config.log_calls = log_calls
 
+    _maybe_reexec_under_wrapper(ctx, app, wrapper, no_wrapper)
+
     if log_config:
         if log_calls:
             LoggingDescriptor.set_call_tracing(True)

robotcode-2.7.0/src/robotcode/cli/__version__.py

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

robotcode-2.6.2/src/robotcode/cli/__version__.py

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