RobotCode Files

Features

• analyze: Add --code filter to code subcommand (4bfc339)

--code restricts the result to the given diagnostic codes (e.g. KeywordNotFound), repeatable and comma-separated, matched case-insensitively like the modifiers. Unlike -mi "*" + re-include, it filters without changing the severity of what remains. It affects the output, summary and exit code, and combines with --severity using AND.

• analyze: Add --severity filter to code subcommand (f565c16)

--severity restricts the analysis result to the listed severities (repeatable and comma-separated; error/warn/info/hint). Filtered-out severities are dropped from the output, the summary counts and the exit code alike, so all three stay consistent. It's orthogonal to --exit-code-mask (which only masks the exit code) and complements the diagnostic modifiers (which remap rather than filter).

• analyze: Add SARIF, GitHub and GitLab output formats (7103836)

robotcode analyze code gains a local --output-format flag (overrides the global --format for this command) with these values:

• concise (default): the human-readable text output
• json / json-indent: structured result (diagnostics + summary)
• sarif: SARIF 2.1.0 log for GitHub code scanning and other consumers
• github: GitHub Actions workflow annotations (::error file=...)
• gitlab: GitLab Code Quality report (JSON array)

--output-file FILE writes the report to a file instead of stdout (for the json/json-indent/sarif/github/gitlab formats), which is handy for CI artifact upload. A missing target directory raises a clear UsageError and other I/O errors surface as a ClickException instead of a traceback.

Mapping details shared across the machine formats:

• LSP 0-based ranges become the 1-based positions SARIF/GitHub expect
• severities collapse onto each format's levels (e.g. SARIF error/warning/ note, GitHub error/warning/notice, GitLab major/minor/info)
• artifact paths are POSIX and relative to the project root (what the CI integrations expect); --full-paths switches to absolute paths
• SARIF and GitLab results carry a stable fingerprint (independent of line number) so alerts survive unrelated edits

• GitHub property/message values are escaped per the @actions/toolkit rules

• analyze: Add JSON output and --full-paths to code subcommand (fc76cf3)

robotcode --format json analyze code (and --format json_indent) now emit a structured result instead of falling back to plain text:

• diagnostics: a map of source path to LSP diagnostics, using the same shape as the discover/results commands so editor and CI integrations can reuse their parsers. Workspace-level diagnostics key on ".".
• summary: file count and per-severity totals.

The JSON always carries the full diagnostic message (tracebacks included); --show-tracebacks only affects the text output.

New --full-paths/--no-full-paths flag (mirroring discover) switches between root-relative and absolute paths in both text and JSON output. JSON keys are always rendered POSIX-style for cross-platform stability.

• analyze: Polish code subcommand output (1049b79)

• Output is now sorted by (file, line, column) so warnings and errors appear in source order instead of mixed by analyzer pass.

• Severity is rendered as a full word, e.g. [ERROR] instead of [E], matching the convention from Robocop, ruff, mypy and friends.
• Robot Framework's appended Python tracebacks and PYTHONPATH dumps are no longer printed by default; the new --show-tracebacks flag opts back into the full message.
• Multi-line diagnostic messages (e.g. MultipleKeywords listing the alternative names) are re-indented with a consistent prefix.

• Related-information entries are prefixed with -> to set them apart visually, and they fall back to (see related location) when Robot Framework provides no secondary message.

• cli: Detect GitHub Copilot agent sessions (dbc5603)

Adds two markers to the AI-agent auto-detection so terminal commands invoked from Copilot get the same clean-output defaults (no color, no pager, REPL plain backend) as sessions from Claude Code, Cursor, Codex, and friends:

• COPILOT_AGENT — set by VS Code Copilot Chat / agent mode in terminals launched via run_in_terminal (microsoft/vscode#311734).

• COPILOT_AGENT_SESSION_ID — set on every shell command and MCP server the standalone GitHub Copilot CLI spawns (>= 0.0.429).

• cli: Adapt automatically to AI agent sessions (8b34a33)

When robotcode is invoked from inside an AI agent (Claude Code, Cursor, Copilot CLI, OpenCode, Codex, Gemini, …) it now drops coloured output, the pager, and the REPL's interactive prompt features — so the agent sees clean line-by-line text instead of ANSI escapes and popup ghosts.

Explicit flags and the usual environment variables (NO_COLOR, FORCE_COLOR, ROBOTCODE_REPL_PLAIN, ROBOTCODE_REPL_BACKEND) still override the detection. ROBOTCODE_NO_AI_AGENT=1 opts out when you want the full experience anyway; ROBOTCODE_FORCE_AI_AGENT=1 turns the agent-mode on for local repros.

• cli: Auto-detect when to emit colors, honor NO_COLOR and FORCE_COLOR (4bbf944)

ANSI escape codes no longer leak into piped output, files, log captures or CI artefacts — colors are auto-disabled when stdout/stderr isn't a TTY. The NO_COLOR and FORCE_COLOR environment variables are now respected. stdout and stderr are decided independently, so warnings keep their colour when stdout is piped but stderr is still on the terminal. Explicit --color / --no-color still override everything.

• discover: Show a diagnostics summary, full list only on demand (4b96656)

robotcode discover no longer prints Robot's parsing errors and warnings by default. When a suite has parse issues, a compact Diagnostics section with the error/warning counts now appears after the statistics, separate from the discovery statistics.

Pass --diagnostics to list the full messages; they are printed before the discovered results, with file paths shown the same project-relative way as the rest of the output. The machine-readable JSON output keeps including the full diagnostics regardless, so editors are unaffected.

• discover: robotcode discover TEXT output is now markdown (a7ef8bc)

robotcode discover subcommands now emit markdown for human output. On a coloured TTY rich renders it to themed ANSI and pages if needed; in a pipe (or with --no-color) the raw markdown is emitted verbatim. JSON output is unchanged.

• info renders as a field/value table.
• files, suites, tests, tasks emit as bullet lists; tags shows one bullet per tag with nested tests/tasks when --tests / --tasks is on.
• all keeps the workspace → suites → tests tree as a nested markdown list, each level indented two spaces.
• Statistics blocks are markdown tables.

The generic markdown helpers used by results — md_table, bold_status, path_paren, display_width, the search highlighter — move from results/_render.py to a shared cli/_markdown.py so both commands import them from one place.

Same commit aligns the existing results renderer on the new label convention: bold is reserved for entities (test/suite /tag names, status); italic marks labels (Tags, Total, Extracted, Summary, metadata keys); (path:line) references are wrapped in inline-code spans so they read as code tokens.

• docs: Add interactive hero image carousel with responsive lightbox (edd6d22)
• language-server: Use the SemanticModel for the "Create Keyword" and "Assign Result to Variable" code actions (6a3d5a3)

When the experimental SemanticAnalyzer is enabled, the "Create Keyword" quick fix (offered for unknown keywords) and the "Assign keyword result to variable" refactor read the keyword call's namespace, library entry and assignment state from the SemanticModel instead of walking the AST and re-resolving via ModelHelper. Output unchanged — covered by dedicated equivalence test files for both code actions.

• language-server: Use the SemanticModel for the "Open Documentation" code action (0768c84)

When the experimental SemanticAnalyzer is enabled, the "Open Documentation" code action reads the pre-resolved keyword data and SemanticTokens from the model instead of looking the keyword up again on every request. Output is unchanged — verified by the existing E2E suite under both paths and a new equivalence test file.

• language-server: Use the SemanticModel for signature help (9415e86)

When the experimental SemanticAnalyzer is enabled, signature help reads the pre-resolved keyword data from the SemanticModel instead of looking the keyword up again on every request. Output is unchanged — verified by running the existing regression suite under both paths and a dedicated equivalence test file.

• repl: Suggest the setting-import aliases in tab-completion (6507af5)

Typing at the prompt now suggests Library, Resource, and Variables next to the keywords, and completing their argument offers the same libraries, resources, and variable files as Import Library / Import Resource / Import Variables — so the Settings-style aliases are as discoverable as the keywords they stand for. Offered only at the interactive prompt, where they apply.

• repl: Make the interactive shell and debugger more consistent (1a11c80)

Several rough edges in the interactive shell and its command-line debugger are smoothed out, so it behaves consistently — both with the rest of Robot Framework and within itself:

• Failures behave like a shell, not a debugger. A failing keyword prints its error and leaves you at the prompt; the debugger only steps in when asked for, and switching it off keeps your breakpoints so switching it back on picks up where you were. (robotcode robot-debug is unchanged for debugging a real run.)
• Imports work like they do in a suite. Write Library, Resource, or Variables at the prompt just as under *** Settings ***; saved sessions keep that familiar layout.

• The debugger speaks one language. Its commands and messages now follow one short, uniform style instead of a mix of phrasings and cryptic notes.

• repl: Add an interactive command-line debugger (8e62733)

Debug Robot Framework runs straight from the terminal — pause a run, see where you are, inspect and change state, run keywords in the live context, and step through execution, no editor required. It's the scriptable, terminal-native counterpart to the VS Code extension's graphical debugger.

• Two ways in. robotcode robot-debug <paths> (alias run-debug) runs a real suite through the normal runner with the debugger attached — same output, options and arguments as robotcode robot, and the run keeps streaming as you step, continue or detach. robotcode repl (alias shell) now has the debugger built in too, so breakpoints fire while you try keywords at the prompt.
• Pause where you want. Line and keyword breakpoints (--break login.robot:42, --break "Open Browser"), an embedded Breakpoint step in a .robot file, --stop-on-entry, and breaking on failures (uncaught failures by default, plus --break-on-all-exceptions, --break-on-failed-test and --break-on-failed-suite). Every stop shows why, which keyword, and where.
• Step through it. .step/.next/.return/.continue/.until, plus .detach (stop debugging but let the run finish) and .abort (end it now).
• Inspect and change state. Walk the call stack (.where/.up/.down/ .frame), list variables by scope (.vars), evaluate in the selected frame (.print/.pprint/.whatis), auto-show expressions at every stop (.display), set variables (.set), and run any keyword right at the prompt in the paused context.
• Manage breakpoints live. List them and add conditional, one-shot, logpoint or command-list breakpoints; set conditions, ignore N hits, delete, and disable/enable by number (.breakpoints/.condition/.ignore/.delete/ .disable/.enable/.commands/.tbreak). Arm exception breakpoints on the fly with .catch.
• Read source and docs in place. .list shows the source at the stop, .source <kw> a named keyword's definition; the full shell command set (.kw, .doc, .imports, .save, …) works at the debug prompt too. On the rich prompt these open in a scrollable full-screen viewer with search and links; on the plain prompt they print inline.
• Built for humans and agents alike. Context-aware completion, syntax highlighting, persistent history and multi-line editing on the rich prompt; --plain (or --backend / ROBOTCODE_REPL_*) gives a bare prompt that reads commands from stdin, and the rich prompt falls back to plain automatically on piped input — so the debugger drives cleanly from scripts, CI or AI agents.

• Long commands accept any unambiguous prefix; one-letter aliases mirror pdb.

• repl: Browse and search keywords from .kw (a884736)

.kw does more than show a single keyword now. With no argument it lists every keyword you have imported, grouped by the library or resource it comes from. With text that isn't an exact keyword name it lists the keywords whose name contains that text, so you can find a keyword without remembering its full name or leaving the REPL. Giving an exact keyword name still shows that keyword's full documentation as before.

In the interactive documentation viewer the listed keyword names are links: Tab to one and press Enter to open its documentation, and press [ to go back to the list — the same navigation the cross-reference links inside a library page already use. On the plain backend the list comes back as text.

• repl: Document imported resources and aliased/argument libraries in .doc and .kw (3d1665d)

The .doc and .kw commands show documentation for the libraries, resources, and keywords you are working with in the REPL. They now cover everything the current session has imported and match how it was imported.

.doc documents imported resource files, not just libraries — the resource introduction plus every keyword with its arguments and description. It also works for libraries that were imported with arguments, which previously could not be shown. Libraries and resources are addressed by the name they were imported under, so a library imported with an alias (AS, or the older WITH NAME) is found by that alias.

.kw accepts the explicit Owner.Keyword form, e.g. .kw BuiltIn.Log, to pick a specific keyword when the same name is provided by more than one import; names resolve the same way they do in a suite. It now also shows full documentation for resource keywords, including the argument table.

Running .doc or .kw on something you haven't imported tells you it isn't loaded instead of showing an empty page. The built-in help for both commands has been rewritten to read as user help rather than internal notes.

• repl: Show a startup banner (73eb26a)

When the REPL starts in an interactive terminal it now prints a Python-style banner with the RobotCode, Robot Framework, and Python versions, plus a hint about .help and .exit. The banner is skipped when stdin is piped/redirected or when running --files without --inspect.

• repl: Documentation viewer and themed prompt out of the box (dda4258)

.help, .kw, and .doc (or F1 for help) open a built-in documentation viewer — a tiny terminal browser for Robot Framework docs without leaving your REPL session.

• Search with /, jump between matches with n/N.
• Click a link, or use Tab/Shift-Tab to step between them. Anchor links jump to the right section, web links open in your browser.
• Walk back and forward through your reading history with [ and ].
• Scroll with the mouse wheel, or with j/k, PgUp/PgDn, g/G.
• Pages use the same renderer the editor shows on hover: signature, argument table with types and defaults, tags, docstring, headings, lists, tables, code blocks.

A single color theme covers the prompt, syntax highlighting, log lines (INFO, WARN, ERROR, …), and the documentation viewer.

prompt_toolkit and rich are bundled with robotcode-repl, so the rich prompt experience is available out of the box. --plain (or --backend=plain) is available for AI-agent sessions and pipe workflows that need clean stdin/stdout.

• repl: Same prompt experience on Linux, macOS, and Windows (f8b8b15)

The interactive REPL ships with a single editor that behaves the same way on every platform. Install the [prompt-toolkit] extra to enable it:

  pip install 'robotcode-repl[prompt-toolkit]'

You get a completion popup, syntax highlighting, signature toolbar, persistent history and Ctrl-R search. Without the extra the prompt degrades to a plain input() line read.

The previously implemented readline-based path has been removed — its behaviour differed too much across platforms and had platform- specific bugs that weren't worth maintaining.

• repl: --backend flag to force a specific input backend (372afca)

Lets you exercise the readline (or plain) code path without uninstalling the prompt_toolkit extra:

  robotcode repl --backend=readline

• repl: Dot-commands, ${_} last-result, signature hints, session export (75cbdfd)

A grab-bag of power-user features for the interactive REPL:

• Dot-commands intercepted before Robot's parser sees them — .help (with per-command drill-down via .help <cmd>), .imports, .vars, .kw <name>, .doc <library>, .history/.history clear/.history del <N>, .cwd, .clear, .save [-a] [-t name] <file>, .exit. Help text on each command documents its flags and shows examples.
• ${_} mirrors the last keyword's non-None return value, like Python's interactive _. Works in the next argument with no ${tmp}= step.
• F1 invokes .help from the prompt; Ctrl-R reverse-search now documented (was already wired via prompt_toolkit defaults).
• Bottom row shows the active keyword's signature with the current argument highlighted when the cursor sits in an argument cell. Named-arg syntax (html=True) follows the spec position, not the positional cell index. Outside an argument cell the row is hidden so the prompt stays uncluttered.
• Embedded-argument completion: Literal[...]-typed parameters on RF 7+ expose their allowed values as completion candidates after name=. Silently no-ops on RF 5/6.
• .save writes the session to a runnable .robot file with imports hoisted into a *** Settings *** section.

All features are prompt_toolkit-aware where it matters but degrade cleanly on the readline and plain backends.

• repl: Session-context toolbar + completion/popup polish (7e0c881)

Adds the bottom-toolbar feature from the original plan plus the last round of UX polish on the prompt_toolkit candidate popup that we shaved down through testing:

• Bottom toolbar shows the running RF version and the cwd at all times — orientation info that's useful when juggling several venvs / project directories.
• Esc closes the candidate popup and reverts any preview text that arrow-navigation had pinned, restoring the user's literal pre-popup buffer. Bound only when the popup is open (has_completions filter) so Esc keeps its Alt-chord prefix role everywhere else.
• Enter on a highlighted candidate accepts it (popup closes, preview becomes permanent). For keyword completions Enter also cleans up the cell — deletes any leftover text after the cursor in the same cell (so a mid-cell completion replaces the whole keyword) and appends a cell separator if no argument follows.
• Tab is smart: cycles through the popup when one is open, inserts a cell separator in argument context, opens the popup otherwise.
• Multi-line history survives a session restart as one entry (newlines are escaped to \\n on disk so the file stays readline-compatible).
• Mid-keyword preview renders cleanly — ${Lo} cursor before o, picking Log To Console now shows Log To Console, not Log To Consoleog (we trim the forward-cell tail from the state's original_document before prompt_toolkit applies the preview).
• TEXT_FRAGMENT in compound variable lookups (${PREFIX_${X}}) renders with the variable-name colour, not the argument colour, so the eye reads the whole concatenated name as one identifier.
• EOL / EOS tokens from Robot's tokenizer are dropped from the rendered fragments — \\n inside a fragment would otherwise show as ^J at the end of every multi-line buffer line.
• Trailing whitespace is padded out to the document's actual length so the cursor stays in sync with the buffer (was sticking at column 0 when the user kept typing spaces).
• _completion.py is consolidated — candidates_for() is now a thin projection over candidates_for_rich(), ~200 lines of duplicated helpers removed (was an artefact of how the rich variant was added in the previous commit).

• CELL_SEPARATOR + find_cell_end() added to _completion.py as named constants and a shared helper, used by the smart-Tab / Enter-cleanup paths.

• repl: Doc hints next to completion popup candidates (c891215)

The prompt-toolkit candidate popup now shows a short context line next to each candidate (prompt_toolkit's display_meta), so you know what a candidate is before picking it:

• Keywords: first line of the keyword's docstring next to the name (Log a message with the given level next to Log, etc.)
• Library / resource / variables imports: the discovery kind — MODULE_INTERNAL for built-ins, MODULE for third-party, RESOURCE for .resource files, FILE for filesystem hits
• Variables (${…}/@{…}/&{…}): repr(value)[:40] of the current value in the live suite scope
• Environment variables (%{…}): repr(os.environ[name])[:40]

Backed by a new candidates_for_rich() API parallel to the existing candidates_for() — keeps the readline backend's path zero-cost (it can't render two-column popups anyway). Works on RF 5/6/7+ with the same attribute-name version-switch (short_doc ↔ shortdoc) the rest of the package already uses.

• repl: Robot-aware syntax highlighting at the prompt (a35b252)

When the prompt-toolkit extra is installed, the prompt now paints Robot Framework syntax in colour. Keywords, arguments, assigns, comments, block constructs (FOR, IF, END, …), BDD prefixes (Given, When, Then, … plus localised variants from RF 6+) and variables all render distinctly.

Variables decompose to the part level: sigil and braces, base name, type hints (${age: int}), default values (%{HOME=default}), subscripts (${dict}[key]), nested forms (${${inner}}), and inline-Python expressions (${{expr}}) all get their own colour.

The highlighter uses Robot's own production tokenizer (robot.api.get_tokens) plus the robotcode semantic analyzer's variable decomposer — the same code path the RobotCode VS Code extension uses for semantic-token rendering. Colour assignments mirror the LSP semantic-token mapping, so the REPL prompt and the VS Code editor use a consistent palette.

No additional dependency: Robot is already required by robotcode-repl, and the variable decomposer ships with robotcode-robot. Works on RF 5, 6, and 7+ (BDD-prefix localisation requires RF 6+; English defaults apply on RF 5).

• repl: Multi-line buffer with block-aware auto-indent (8cfcc4c)

When you open a Robot block (FOR, WHILE, IF, TRY, GROUP), the next line of input is auto-indented to the matching depth. END pops one level. Nested blocks stack — IF inside FOR lands at depth 2.

Behaviour differs slightly between backends:

• readline (always available): each continuation line is its own input() call. The ... prompt seeds the buffer with the right number of spaces via set_pre_input_hook. You type from there.
• prompt-toolkit (with the optional extra): one multi-line buffer per top-level statement. Plain Enter is smart — submits when the block is balanced, otherwise inserts a newline + auto-indent so you keep typing inside. Alt-Enter (Esc Enter) and Ctrl-J always insert a newline + auto-indent, even when balanced. Cursor-Up/Down navigates inside the buffer.

Shift-Enter is intentionally not bound — most terminals can't deliver it distinctly from plain Enter. Alt-Enter and Ctrl-J cover the use case portably.

• repl: --plain flag to skip all prompt enhancements (bf9fc5b)

robotcode repl --plain (or ROBOTCODE_REPL_PLAIN=1) bypasses the prompt-toolkit / readline cascade and falls back to a bare input() call — no history, no Tab-completion, no candidate popup, no auto-suggest, no syntax highlighting.

Recommended for:

• AI-agent invocations where ANSI escapes from the candidate popup would corrupt the stdout capture the agent reads back
• Automation pipelines and CI that pipe input via heredoc
• Wrapper scripts that need a deterministic, side-effect-free prompt

--plain and --no-history are orthogonal — plain mode has no history file anyway, but combining the two is safe and does not raise.

• repl: Live as-you-type completion with prompt_toolkit (b449e1b)

pip install 'robotcode-repl[prompt-toolkit]' swaps the readline frontend for one driven by PromptSession:

• Live candidate popup under the cursor as you type — no Tab needed (though Tab still works). Arrow-keys pick, Enter accepts. The verbose Import Library Foo / Import Library Bar row layout is replaced by just the labels.
• Fish-style auto-suggest — last matching line you typed shows greyed-out behind the cursor, right-arrow accepts it.
• Ctrl-R reverse search with a dedicated UI, bracket auto-match, multi-line cursor movement inside open blocks.

The completer runs in a background thread (complete_in_thread=True) so the popup never blocks the UI, and Robot's expensive complete_*_import(None, …) filesystem / sys.path discovery is cached for the session — even with hundreds of importable modules, only the first keystroke pays the walk cost.

Candidate sourcing reuses the same Robot-aware logic the readline backend uses, and the history file is shared on disk between the two backends — swapping extras (or having neither) doesn't lose arrow-up recall.

• repl: Tab completion for keywords, variables, imports (72cdbc2)

Tab now completes Robot-aware:

• keyword names at the start of a cell, sourced from every loaded library and imported resource (case + whitespace + underscore insensitive — matches Robot's own resolution rules)
• ${...} / @{...} / &{...} variables from the live suite scope, and %{...} environment variables from the process environment
• Import Library arguments — plain identifiers (Coll<Tab> → Collections), dotted module paths (robot.libraries.Coll<Tab> → robot.libraries.Collections), and filesystem paths (./libs/My<Tab> → ./libs/MyLib.py)
• Import Resource arguments — .robot / .resource files only
• Import Variables arguments — .py / .yaml / .yml / .json variable files plus discoverable variables modules

Works across Robot Framework 5, 6, and 7+.

On Pythons whose stdlib readline is backed by libedit (macOS system Python, some uv / python-build-standalone builds), install the gnureadline extra for full GNU readline behaviour: pip install robotcode-repl[gnureadline].

• repl: --no-history flag for ephemeral sessions (1c28b57)

robotcode repl --no-history skips loading and saving the persistent history file. Arrow-up still recalls lines from the current session; nothing leaks across sessions. Useful for AI-agent invocations, quick spike sessions, or working with secrets you don't want sitting in .robotcode_cache/repl_history. Also picked up from the ROBOTCODE_REPL_NO_HISTORY env var, which is handier when the REPL is launched by a wrapper script.

• repl: Fish-style history dedup and configurable size (1c93402)

Re-running a command that's already in the history no longer leaves the older copy behind — only the most recent invocation survives, so arrow-up cycles through unique commands (the same behaviour fish shell ships). Legacy history files with duplicates are cleaned up on first load.

The buffer size is now configurable via the ROBOTCODE_REPL_HISTORY_SIZE environment variable; default stays at 1000 entries.

• repl: Persistent line history across sessions (9c99f43)

robotcode repl now remembers the lines you typed and recalls them with Pfeil-hoch / Ctrl-R, just like Python's own shell or bash. The history file lands in your project's .robotcode_cache/ when one is detected, otherwise in the per-user cache directory. ROBOTCODE_CACHE_DIR overrides both.

• results: robotcode results TEXT output is now markdown (4b94d66)

robotcode results subcommands now emit markdown for human output. On a coloured TTY rich renders it to themed ANSI and pages if needed; in a pipe (or with --no-color) the raw markdown is emitted verbatim — ideal for pasting into PRs, Slack, or feeding to an LLM. JSON output is unchanged.

• summary, show, log, stats and diff open with a markdown heading and lay out content as tables, bullet lists, blockquotes for failure messages, and inline code for log output.
• Each status shows both an icon and the bold word (✅ PASS, ❌ FAIL, ⏭ SKIP, ⏸ NOT RUN, ⚪ NOT SET). summary and stats tables are column-padded so the raw markdown stays aligned under cat/less.
• log renders each test body as a nested list: keywords, control flow (FOR, WHILE, IF, TRY, VAR, GROUP), setups and teardowns. Argument values appear as inline-code spans; failure messages as blockquotes between a keyword and its children. Log output renders as - `[INFO] text`; multi-line messages get a fenced code block.

• Artefacts attached to log messages render as markdown: images as ![name](url) so GitHub, Slack and VS Code show them inline; other files as [path](url) so OSC 8-aware terminals (rich, wezterm, iTerm2) make them clickable. Link targets prefer paths relative to cwd and fall back to file:// URLs when the artefact lives outside cwd; --full-paths forces file:// URLs everywhere.

• results: Unify failure vocabulary across results subcommands (e3a0bd3)

summary uses --failed/--no-failed for the failures listing (with failed as the matching JSON field), lining the wording up with --status fail everywhere else.

show, log, and stats gain --failed, --passed, and --skipped as additive shortcuts for --status fail|pass|skip. They stack with each other and with --status, so results show --failed --skipped is --status fail --status skip without the typing.

• robot: Enable bottom-up navigation in the SemanticModel (a87fc79)

Every SemanticNode now carries a parent back-pointer, so LSP features that start from a token or statement can walk up to the enclosing block, section, or definition without re-querying the model by line. Comes with helpers enclosing_definition_block, enclosing_block_of_kind, enclosing_section, and path_from_root on SemanticModel.

Parent is typed as SemanticNode (not SemanticBlock) so it can also point at a Statement — RunKeywordCallStatement.inner_calls are parented to their outer Run-Keyword statement.

• robot: Pre-resolve more semantic data so LSP features can read it once (be36e61)

Inlay Hints now read from the SemanticModel instead of doing a second analysis pass. The model gains a real block hierarchy (FOR/WHILE/IF/TRY/ GROUP), pre-resolved init keyword docs on Library/Variables imports, and consolidated header-token construction so future LSP feature migrations stop re-walking the AST.

The old AST-walk path stays as fallback while robotcode.experimental.semanticModel is off; both paths must produce identical hints (covered by parametrized equivalence tests across all supported RF versions).

• robot: Implement cross-platform file locking for data cache (8ae4aec)

Replace the Unix-only flock-based locking with a platform-dispatched implementation using LockFileEx/UnlockFileEx (Windows) and fcntl.flock (Unix/macOS). The Windows path previously had no-op early returns, meaning the exclusive lock used by cache prune provided no actual protection on Windows.

• robot: Introduce SemanticModel for richer Robot Framework analysis (Part 1) (23a538c)

Introduce the first part of an opt-in SemanticModel that provides deeper static analysis of Robot Framework files, available behind a feature flag.

Enable via robot.toml:

  [tool.robotcode-analyze]
  semantic-model = true

or in VS Code settings:

  "robotcode.experimental.semanticModel": true

• Nested variable resolution: variables like ${DICT_${key}} are now statically resolved where possible, with diagnostics when resolution fails
• Richer semantic highlighting: token classification driven by the semantic model instead of syntactic heuristics
• RF 7.4 type hint support: KeywordName/KeywordArgument annotations are recognized for run-keyword detection
• Log output to verify which analyzer is active
• Robust deserialization of cached library data when new fields are added

The SemanticModel is disabled by default. Further parts will add additional LSP feature migrations and extended analysis capabilities.

• runner: Extend results & discover search and add log --keyword-info / --suite-info (9559316)

--search / --search-regex reach more places now. On top of the existing test name / body / tags targets, they also hit:

• every executed keyword's [Documentation], [Tags] and [Timeout] — answer questions like "which tests touched a keyword tagged slow" or "which tests called a keyword whose docstring mentions rate-limiting".
• any ancestor suite's Documentation or Metadata — a hit on a suite-level field keeps every test underneath, so --search "API tests" picks up every test in a suite whose docstring reads "API tests" without enumerating names.

Both rules apply to results and discover alike.

results log gains two opt-in views (default off — the plain log stays compact):

• --keyword-info prints each executed keyword's [Documentation], [Tags] and [Timeout] under its header, so the log shows what each keyword is, not just what it was called with.
• --suite-info groups tests under a Suite: header that carries the suite's name, source, status, Documentation and Metadata — useful when scanning a multi-suite run to see at a glance which suite a test belongs to and what it's about.

They compose: log --suite-info --keyword-info gives a structured view that mirrors the layout of the original .robot files.

• runner: Add --search / --search-regex to discover commands (ce8c783)

discover all / tests / tasks / suites / tags / files now support the same search flags as the results family. Filtering runs through a SearchModifier SuiteVisitor wired into the existing prerunmodifier slot, so the Collector only ever sees the surviving tree — statistics, ancestor suites and the tag aggregate fall out of that automatically.

Search targets per test: name, full name, source path, documentation, template, timeout, tags (normalisation-aware), and the full body — keyword names, arguments, assigned variables, FOR/WHILE/IF conditions, VAR/RETURN values, EXCEPT patterns, GROUP names, plus setup/teardown. TEXT output highlights matches in name/source/tags/path; JSON output echoes the pattern in filtersApplied.

To avoid duplication, the search infrastructure moves into a shared runner/cli/_search.py module: SearchMatcher (with a model-agnostic matches_body method that walks both robot.running and robot.result body trees via duck-typing), make_search_matcher, make_highlighter and the new SearchModifier. results.py and _render.py switch to the shared module and drop their local copies.

• runner: Add the standard result filters to results diff (a10f6ce)

results diff now accepts the same filter options as the other results subcommands: --status, -i/--include, -e/--exclude, -s/--suite, -t/--test, -bl/--by-longname, -ebl/--exclude-by-longname, plus --search / --search-regex. Each filter is applied identically to both baseline and current before the diff, so the comparison can be scoped to a single suite, tag pattern, name, or message snippet:

robotcode results diff baseline.xml -s "MyProject.Login" robotcode results diff baseline.xml -i smoke robotcode results diff baseline.xml --search TimeoutError robotcode results diff baseline.xml -bl "MyProject.Login.Bad Password"

DiffResult gains a filtersApplied field (additive, optional) so the JSON output records the filters in the same shape used by the other result models.

• runner: Add -bl/--by-longname and -ebl/--exclude-by-longname to results filters (33697cb)

robotcode results now accepts long-name filters alongside the existing --status, -i/--include, -e/--exclude, -s/--suite, -t/--test options. Pick a specific test or suite by its full long name (exact match), or exclude a branch of the tree the same way:

robotcode results show -bl "MyProject.Login.Bad Password" robotcode results summary -ebl "MyProject.Slow Suite" robotcode results stats --by tag -bl "MyProject.Smoke" robotcode results log -bl "MyProject.Login" -bl "MyProject.Logout"

Both options compose with the existing filters and --search / --search-regex, and surface in JSON filtersApplied as by-longname / exclude-by-longname for CI consumption. Available on summary, show, log, and stats.

Along the way, trimmed redundant "repeat for OR" notes from option help texts — Click already shows the * marker on repeatable options.

• runner: Split --search and --search-regex, add to summary and stats (89c2952)

--search-regex is now a standalone option that accepts a pattern instead of a boolean flag — you no longer have to spell out both --search TEXT --search-regex. The two options are mutually exclusive:

• --search TEXT — case-insensitive substring match (open browser, TimeoutError, …)
• --search-regex PATTERN — Python regex, honoured as written. Use (?i)pattern for case-insensitive matching, just like in any regex engine.

Both options now work on summary, show, log, and stats, so the same search vocabulary applies across the whole results family:

robotcode results summary --search TimeoutError robotcode results stats --by tag --search Browser robotcode results show --search-regex "AssertionError.*" robotcode results log --search "Open Browser"

Search traverses the raw output tree (test attributes plus keyword names, arguments, and log messages), so a single search reaches into the execution body without first materialising the full per-test log.

• runner: Add results diff for comparing two runs (bbdcf33)

results diff BASELINE [CURRENT] compares two output.xml / output.json files and reports tests whose status changed, plus tests that appeared or disappeared between the runs. Categories:

• New failures — passed in baseline, fails in current
• New passes — failed or skipped in baseline, passes in current
• Status changes — any other status flip
• Added — only in current
• Removed — only in baseline

If CURRENT is omitted, it falls back to the active profile's auto- discovered output file, so the common pattern is robotcode results diff /path/to/baseline.xml after the latest run. Use --only new-failures (repeatable) to narrow the view; combined with --format json this gives CI pipelines a clean signal for PR feedback without parsing output.xml themselves.

Exit code is always 0 — the command is for inspection, not gating.

• runner: Add --search / --search-regex to results show and log (1e90209)

results log and results show now accept --search TEXT to narrow the output to tests that mention the given text — searched across test name, failure message, keyword names, keyword arguments, and log messages. Case-insensitive substring match by default; pass --search-regex to use a Python regular expression instead.

In log's TEXT output, every match is highlighted with a yellow background so the relevant lines stand out at a glance — handy for tracking down which test triggered a particular TimeoutError without reopening log.html. JSON output records the search pattern in filtersApplied for auditability but stays free of markup.

--search composes with the existing filters (--status, -i/-e/-s/-t), so combinations like "failures that mention AssertionError" or "smoke tests where Open Browser was called" come naturally.

• runner: Add results stats subcommand (d1fa30f)

results stats aggregates a finished run by --by tag, --by suite, or --by status — the same dimensions report.html exposes in its "Statistics by Tag" / "Statistics by Suite" panels. Repeat --by to render multiple sections in one call.

Each section is a table with pass/fail/skip counts and total elapsed time per group, sorted by failures (descending) by default. Switch to --sort elapsed, --sort total, or --sort name, and limit rows with --top N. The standard --status, -i/--include, -e/--exclude, -s/--suite, -t/--test filters narrow the test set before aggregation, so combinations like "tag stats for the smoke suite, top 10 by failures" come out of the box.

JSON output exposes a stable StatsResult / StatsSection / StatsGroup schema for CI consumption.

• runner: Add --sort and --reverse to results show (e4d693c)

results show can now sort tests by name, suite, status, elapsed, or start before display. Pair with --top N for triage views like "the slowest 10 tests" or "failures first". --reverse flips the order; without --sort, execution order is preserved (the existing behaviour).

status orders FAIL → SKIP → PASS → NOT RUN (matching report.html's custom sort), and elapsed defaults to longest-first so the most expensive tests bubble to the top. A dim footer line Sorted by FIELD (desc) is emitted in TEXT mode when a sort is active; JSON output reflects the order in the tests array.

• runner: Unify results log filters and add --max-depth (02bb47b)

results log now uses the same filter options as results show and results summary — pick tests by --status, -i/--include, -e/--exclude, -s/--suite, or -t/--test. The old TEST_PATTERN positional and --failures-only flag are gone; use -t "*Login*" and --status fail instead.

A new --max-depth N collapses deeply nested keyword calls. The keyword header still prints, and a dim … N hidden (--max-depth N) marker takes the place of the body so nothing disappears silently. Default 0 keeps the behaviour unchanged (full tree). The previous --keywords/--no-keywords toggle is dropped — without keyword grouping the output overlapped with results show.

See docs/03_reference/cli.md for the refreshed option reference.

• runner: Add results command to inspect Robot Framework runs (cf67abf)

After running tests, robotcode results lets you explore the output without opening report.html or re-running the suite — handy for CI logs, agent-driven workflows, and quick failure inspection from the terminal.

Three subcommands:

• robotcode results summary — overall status, pass/fail/skip counts, run duration, and the total number of error and warning messages. --failures adds the list of failed tests above the counts.
• robotcode results show — one line per test with its status, source link, and failure message. Filter by status, tags, suite or test name pattern.
• robotcode results log — the full execution tree: every keyword call, control structure, and log message, just like Robot's report.html but in your terminal. --failures-only, --level WARN, --extract DIR (pulls out screenshots and embedded artefacts), and more.

The output file is auto-discovered from your active robot.toml profile; override with -o/--output PATH. Test names carry a (path:line) suffix that VS Code's integrated terminal turns into a clickable goto-source link. Pass --format json (or toml) for a structured, agent-friendly payload.

See docs/03_reference/cli.md and robotcode results --help for the full reference.

• vscode: Add commands to register the chat plugins marketplace (0e2b02f)

Two new Command Palette commands let you pull the RobotCode chat plugins marketplace into VS Code without editing settings by hand:

• "RobotCode: Add Chat Plugins Marketplace"
• "RobotCode: Remove Chat Plugins Marketplace"

They add or remove robotcodedev/robotframework-agent-plugins in the user-level chat.plugins.marketplaces setting, so GitHub Copilot Chat can discover and install RobotCode plugins (and future ones from that marketplace). This is the marketplace route — separate from the plugin the extension already bundles via contributes.chatPlugins.

If you install the robotcode plugin from the marketplace, disable the bundled one by turning off robotcode.ai.enableChatPlugins to avoid running two copies of the same plugin.

Only the applicable command is shown: Add when the marketplace is not registered, Remove when it is. Removing also clears the entry when it was added as a GitHub URL rather than the owner/repo shorthand.

• vscode: Bundle AI chat plugins (4018a4f)

The extension now bundles chat plugins for GitHub Copilot Chat in VS Code. When enabled, the agent uses the project's robotcode CLI to answer Robot Framework questions and run tasks, honoring the project's robot.toml, profiles, and Python environment.

For example:

• "run the smoke tests with the ci profile" runs them through the selected profile and reports pass/fail counts
• "why did Login Works fail?" inspects the existing run results instead of loading output.xml into the chat
• "what tests and tags exist?" uses robotcode discover, which resolves the real set (paths, profiles, variables, pre-run modifiers) rather than grepping .robot files
• "what arguments does this keyword take?" looks it up with libdoc against the installed libraries and local resources
• "try this keyword" runs it in the REPL

Enabled by default; toggle with robotcode.ai.enableChatPlugins.

For other AI agents (Claude Code, Codex, and other Open-Plugin-compatible tools), the same plugins are published as a marketplace: https://github.com/robotcodedev/robotframework-agent-plugins

• vscode: Disable chat language model tools by default (3c47b48)

RobotCode now includes a robotcode CLI-based chat plugin for chat assistance. They use the same CLI workflows RobotCode users already know for setup, configuration, profiles, discovery, analysis, test runs, result inspection, and REPL usage.

The existing VS Code Chat language model tools are now turned off by default. They provide chat access to RobotCode information such as keyword documentation, library documentation, document imports, and environment details.

Users who still need these tools can enable robotcode.ai.enableLanguageModelTools.

The setting remains visible in VS Code for now and notes that the language model tools are planned for deprecation and later removal.

• vscode: Add global setting to disable What's New notification (fa03c08)

Allow users to turn off the update notification that appears after RobotCode has been updated. The new robotcode.showWhatsNewOnUpdate setting can be found in the global VS Code settings under RobotCode > General.

• Add inline documentation and examples to robot.toml.json (825f891)

Users now get rich documentation directly in their editor when editing robot.toml configurations through JSON schema integration. The schema works seamlessly with the Even Better TOML VS Code extension (https://marketplace.visualstudio.com/items?itemName=tamasfe.even-better-toml), which is powered by Taplo.

Enhancements to robot.toml.json:

• Comprehensive inline documentation (markdownDescription) for every field
• TOML code examples extracted from configuration docs
• Direct links to RobotCode documentation via Taplo integration
• Full compatibility with Even Better TOML and other Taplo-based editors

Improvements to schema generator:

• Complete type hints for all inner functions
• Detailed docstrings for better code clarity
• More robust TOML code block extraction regex

Bug Fixes

• analysis: Respect diagnosticMode for workspace files (d2f8114)

Diagnostics for closed workspace files could appear (or be suppressed) inconsistently in openFilesOnly mode, depending on which file the workspace diagnostics loop happened to iterate last.

Also clarify the diagnosticMode description so it no longer implies that background analysis is restricted -- the setting only controls which files diagnostics are reported for.

• analyze: Run unused diagnostics through the diagnostic modifier (f13b678)

collect_unused_keywords / collect_unused_variables returned their diagnostics directly, bypassing the diagnostic modifier. As a result the KeywordNotUsed / VariableNotUsed diagnostics could not be ignored or restyled via -mi/-mX or # robotcode: comments, unlike every other diagnostic. Pass their result through modify_diagnostics, the same way collect_diagnostics does.

• analyze: Tighten path filtering and refine code output (b0b8820)

• Path arguments to robotcode analyze code are now matched segment-wise: passing tests/api no longer pulls in siblings like tests/api_v2.

• Workspace-level diagnostics (e.g. variable/library import errors) are now prefixed with .: instead of being printed without any source marker; their related-information lines keep their line/column.
• The summary line picks its color from the highest severity present (red/yellow/blue/cyan) instead of only highlighting errors.

• Unused-keyword/variable collectors are only registered when --collect-unused is set, and empty document reports from the analysis pass are no longer emitted.

• analyze: Ignore intentionally unused variables in CLI diagnostics (9cba5b0)

Treat variable names starting with "_" as intentionally unused in CLI unused-variable diagnostics, matching the language server behavior.

• bundled: Quote arguments in robotcode script to handle spaces correctly (4311747)
• config: Allow "NONE" string for max-error-lines in robot.toml (6f2e5e1)

You can now set max-error-lines = "NONE" to show the full error message, matching Robot Framework's --maxerrorlines NONE. Integers keep working as before; any other string is rejected with a clear error.

• discover: Render arbitrarily deep suite trees in markdown output (3825939)

robotcode discover all (and any other markdown output) now renders the full workspace tree no matter how deeply suites are nested. Previously, projects nested past ~8 levels had everything below the limit silently dropped — including the trailing ## Statistics block — because rich's markdown parser caps nesting at 20 and every list level consumes two of that budget.

Markdown is now rendered through a parser configured for deep nesting, so the whole tree and its statistics always appear. Headings are left-aligned and tables render without the extra blank lines rich inserts by default.

rich is now a direct dependency of the plugin package (the lowest package that renders markdown); the repl package picks it up transitively instead of declaring it separately.

• docs: Fix sidebar links treated as external URLs (9b393ec)

vitepress-sidebar generates base:"/" with links starting with "/", causing VitePress to produce protocol-relative URLs ("//path") that browsers interpret as external links. Remove the redundant base:"/" from the root sidebar group so absolute links resolve correctly.

• language-server: Honor semantic model setting changes (782d83d)
• packages: Pin internal robotcode dependencies to exact version (7e4e9f2)

Updating a single robotcode package now pulls the matching versions of its robotcode dependencies along with it. Previously the inter-package dependencies were unconstrained, so upgrading one package could leave its siblings on an older release and break the installation.

The pins are kept in sync automatically on each release.

• plugin: Suppress mypy type-arg warning on click.ParamType subclass (ecf88e7)

A recent mypy / click version bump started flagging AddressPortParamType(click.ParamType) as 'Missing type arguments for generic type ParamType'. Suppress with # type: ignore[type-arg] inline — the class deliberately omits the type parameter because the value shape is heterogenous (parsed by convert).

• plugin: Make click help-text generation deterministic (b45757c)

The MutuallyExclusiveOption help text joined a Set[str] and EnumChoice returned set(choices).difference(excluded) — both produced non-deterministic ordering, so regenerating cli.md always re-shuffled the option lists. Sort the mutex set; preserve enum definition order via a list comprehension. Regenerate cli.md so the typo fix from eeb8979a actually lands in the docs and the option ordering is stable across future runs.

• repl: Handle all return-value assignment forms in completion and argument hints (bad6e14)

Keyword completion and the status-bar argument hint now work after any return-value assignment Robot Framework allows — including item assignment (${x}[0], ${d}[key]) and type hints (${x: int}), not just a plain ${x} =. The keyword is resolved with Robot Framework's own variable parser, so the REPL matches real assignment syntax exactly. The status-bar hint, which previously showed nothing once an assignment was present, is fixed too.

• repl: Keep keyword completion working after a return-value assignment (dc5d0be)

Starting a line with a return-value assignment — ${result}= Some Keyword, or several targets like ${a} ${b}= … — no longer turns off keyword completion in the keyword cell. Completion and Tab now skip the assignment targets and complete the keyword (and then its arguments) just as they would without an assignment.

• repl: Prevent multiple concurrent REPL executions (1edfe13)
• repl: ${_} now mirrors every keyword result, including None (45ec8fa)

In the REPL, ${_} holds the result of the last keyword. Previously keywords that return None (such as Log) left ${_} untouched, so the most natural first step — Log hello then Log ${_} — failed with "Variable '${_}' not found".

${_} now always reflects the most recent keyword and is set to None when a keyword returns nothing. It's also seeded to None at startup, so ${_} resolves even before the first keyword runs.

• repl: Resolve relative import paths against the working directory (8a34747)

Imports such as Import Resource foo/my.resource typed at the REPL prompt now resolve relative to the REPL's working directory, just like the same import does in a .robot file. Previously such imports only worked when the path was absolute, prefixed with ${CURDIR}/, or reachable via the module search path.

This matches Robot Framework's own resolution since RF 7.4. The REPL docs also note that on RF < 7.4 bare relative paths still fail (RF itself doesn't resolve them that way on those versions); use ${CURDIR}/... or put the directory on the module search path instead.

• repl: Keep REPL startup working on pyreadline3 (Windows) (7ba1a01)

robotcode repl crashed on startup on Windows when launched against pyreadline3 and a history file that still had legacy duplicates — pyreadline3 doesn't expose remove_history_item, so the dedup pass tripped on AttributeError before the prompt ever appeared.

History dedup and .history del <N> now feature-detect remove_history_item and fall back to a clear_history + re-add_history rebuild when the running readline shim doesn't expose it. CPython's GNU readline path is unchanged.

• repl: Preserve backslashes in dot-command argument paths (ed2b91a)

.save C:\Users\…\scratch.robot mangled the path on Windows because shlex.split consumes backslashes as escape characters. Switch to a custom shlex with escape="" so paths arrive intact while shell-style quoting (for spaces in paths) still works.

• repl: -d/--outputdir was silently ignored (06bc85d)

robotcode repl -d ./results -o output.xml used to write the file into the working directory instead of ./results. The directory now honours -d, the output-dir setting in robot.toml, and robot's default precedence in that order. Both repl and repl-server are fixed.

• repl, repl-server: -v / --variable and -V / --variablefile now work (7ecdd82)

Both flags on robotcode repl and robotcode repl-server were broken — -v BASE_URL:staging did not register the variable, and -V vars.yaml did not load the file. They now behave the same as the matching robot flags: -v sets inline name/value pairs, -V reads variables from .yaml / .py / .json files. Repeat either flag to set multiple at once.

• robot: Fix Run Keyword If nested run keyword handling in all branches (1d283aa)

All three Run Keyword If branches (IF, ELSE, ELSE IF) now use skip_args() + _analyze_keyword_call(analyze_run_keywords=True) so nested run keywords receive only branch-local tokens instead of consuming ELSE/ELSE IF markers.

• robot: Correct type-hint handling in semantic analyzer (ecfde21)

strip variable type hints only in declaration contexts preserve typed names in usage lookups resolve nested typed variable declarations correctly stop splitting type hints on additional colons in tokenizer add regression tests for variables, VAR, assignments and arguments

• runner: Keep relSource in results JSON regardless of --full-paths (e4ff456)

Aligns results with discover, which always carries both source (absolute) and relSource in its JSON output. Two changes:

• _make_test_item / _make_diff_change / LogTest stop conditionally setting rel_source=None when --full-paths is on. The flag is now purely a TEXT-rendering hint.
• _rel_to_cwd falls back to the original path (instead of None) when the source isn't anchored under cwd, mirroring discover.get_rel_source. Consumers like the VS Code extension can now rely on relSource being present whenever source is.

_make_diff_change and _make_test_item no longer take full_paths, since the parameter became unused after the change. Call sites updated.

Plus acceptance tests covering the harmonised behaviour on summary, show, log and diff, and a TEXT-only --full-paths test on discover tags (the last subcommand without coverage).

• runner: Chdir into root_folder in discover files (b92acdc)

The other discover subcommands wrap their work in with app.chdir(root_folder) via handle_options, so get_rel_source produces paths relative to the project root. discover files skipped that step, which made its default (non---full-paths) output depend on the caller's process cwd: if cwd was outside the project, paths fell back to absolute, breaking the documented semantics.

Wrap the body in the same chdir context so the output is consistent with the rest of discover. Also flips a fragile test_files_default_ relative from ordering-dependent (it would fail in the full suite when an earlier test left cwd in a tmp dir) to robust.

• runner: Honour subcommand semantics in discover JSON output (0f26a3f)

Two discover subcommands silently differed between their TEXT and JSON renderers because the type filter only ran in the TEXT path:

• discover tests -f json returned every item in collector.test_and_tasks — i.e. tasks slipped in too, even though the TEXT render correctly filtered to type == "test". Same shape bug on discover tasks. Filter the list before handing it to ResultItem so JSON and TEXT agree.
• discover tags --not-normalized -f json ignored the flag and always returned the normalised tag dict; only the TEXT path consulted --normalized. Pick the right collector dict (tags vs normalized_tags) for both renderers.

Both surfaced while wiring up the new discover acceptance tests.

• runner: Page discover output through a single pager invocation (069c34e)

Each discover subcommand opened the system pager multiple times in sequence — once for the main listing, then once for the statistics block (and once per key for discover info). The fix routes everything through a single echo_via_pager call so the user only sees one pager instance.

• runner: Normalise tags in results commands (8f93500)

Robot Framework treats tags as equal when they differ only in case, whitespace, or underscores (Bug 1 ≡ bug_1 ≡ Bug1). The new results commands didn't honour that:

• stats --by tag showed each spelling variant as its own bucket, even though they referred to the same semantic tag.
• tests[].tags in show / summary --failures echoed the raw form from the result file, so the same tag could appear with different spellings on different tests.
• --search / --search-regex against tags compared the raw strings, so --search "bug 1" missed tests literally tagged bug_1.
• filtersApplied.include/exclude echoed the user input verbatim, which didn't reflect how Robot actually interpreted the pattern.

Every tag-handling spot now uses Robot's normalize(..., ignore="_"):

• Stats buckets group by the normalised form and display the normalised label too.
• _make_test_item emits already-normalised tags in JSON / TEXT.
• _SearchMatcher carries a separate tag-aware predicate that normalises both haystack and needle (substring) or just the haystack (regex).
• _canonical_tag_pattern normalises plain single-tag patterns in filtersApplied; patterns containing an uppercase AND / OR / NOT operator are echoed verbatim because each operand would need individual normalisation.

Tests added: stats merges equivalent tags into one bucket; show emits normalised tags; --search is normalisation-aware against tags; filtersApplied echoes the canonical pattern form. The tagged.robot fixture grew three new tests (norm tag, norm_tag, NormTag) so the regression case is exercised end-to-end.

• runner: Make results commands work against older Robot Framework outputs (20bb597)

robotcode results failed on output.xml files generated by Robot Framework 5 and 6 — the older models use different attribute names than RF 7 (elapsedtime vs elapsed_time, starttime/endtime as the YYYYMMDD HH:MM:SS.fff string, no variables on WhileIteration, …).

Each accessor now falls back to the legacy spelling and the iteration helper limits loop-variable lookups to ForIteration via isinstance, so summary, show, log, stats, and diff produce identical output regardless of which Robot version wrote the file. Timestamps in the legacy string format are normalised to ISO 8601 in the JSON contract.

Smoke-tested across RF 5.0, 6.0, 7.0, 7.3, and 7.4.

• runner: Escape <errors> in results log help to prevent VitePress build error (7dc79ef)

The --execution-messages help text contained a raw <errors> tag that VitePress' Vue parser interpreted as an unclosed HTML element, breaking the generated cli.md docs page. Wrap it in backticks so it renders as inline code and is ignored by the template compiler.

• schema: Revert robot.toml json-schema, because older versions of robotcode need this (fafb168)
• vscode: Let Tab accept Copilot inline edit suggestions (f724aa2)

When "4 Spaces Tab" was enabled, pressing Tab inserted four spaces instead of accepting or jumping to Copilot's inline edit (Next Edit) suggestions. Tab now yields to those suggestions and only inserts spaces when none is pending.

• vscode: Update stale RF version UI strings from 4.1 to 5.0 (#605) (f846483)

The quick-pick dialog shown when environment validation fails still referenced 'robotframework version 4.1 or higher' in both the 'Select Python Interpreter' detail and the 'Retry' detail text. The actual enforced minimum has been 5.0 since commit 02cf495f (refactor: introduce RF_VERSION constant and remove RF < 5.0 dead code).

Documentation

• analyze: Document the -mi "*" allow-list pattern (b5b2444)

Show that * matches every code, so -mi "*" plus re-introducing specific codes builds an allow-list — and point out it remaps severity, unlike the --code filter.

• analyze: Document the --code filter (e72ac55)

Fold --code into the "reporting only some diagnostics" section next to --severity, noting that both filter (rather than remap) and combine with AND.

• analyze: Document --severity filter and unused diagnostic control (2da8116)

• describe the new --severity output filter alongside the modifiers

• note that KeywordNotUsed/VariableNotUsed can now be remapped or ignored like any other diagnostic

• analyze: Streamline and correct analyze-code guide (0272ab9)

• drop the flag table; defer to the CLI reference

• move the JSON reference to the end
• trim implementation internals from the SARIF section and give every output format a consistent invocation + example
• note that the CI examples assume project setup via its package manager
• fix a dead anchor link

Corrections after review:

• no paths analyzes/reports the whole project, not the profile's default paths; paths/--filter narrow the reported per-file diagnostics while import/library resolution always covers the whole project
• explain why --collect-unused is opt-in (needs whole-project reference data, extra pass, slower with many keywords/variables)
• note that a real run or discovery can surface errors static analysis misses (suite-wide checks like duplicate test names, PreRunModifier)

• show how to read the bitwise exit code from the shell

• analyze: Document CI workflows, drop scratch workflow (fcb0caa)

Replace the fragmentary CI snippets in the analyze-code guide with full, copy-pasteable workflows for GitHub code scanning (SARIF upload), GitHub inline annotations, and GitLab Code Quality — including the security-events: write permission and current action versions (checkout@v5, upload-sarif@v4) that the manual trial surfaced.

Remove the throwaway .github/workflows/analyze-code.yml now that the examples live in the documentation.

• analyze: Add reference guide for analyze code (095b52a)

Add a task-oriented guide for robotcode analyze code under docs/03_reference, in the style of the discover/results guides: what it checks, severities and diagnostic modifiers, exit codes and masks, all output formats (concise, json, sarif, github, gitlab), a flag reference, JSON/SARIF/GitHub/GitLab output references, CI recipes, and the cache subcommands. Link it from the reference index.

• cli: Enhance command options documentation for severity and code filters (422d466)
• cli: Document core, results and testdoc commands (b48a58d)

Add the missing commands to the package overview: the core robotcode package now lists config and profiles, and the runner package lists results and testdoc. Close the reference with help hints and links to the related configuration, discovery, results and REPL pages.

• config: Show TOML examples in robot.toml reference (c53da77)

The "Examples:" blocks were carried over verbatim from Robot Framework's CLI help, so they showed --flags instead of TOML. Add a curated TOML_EXAMPLES map in generate_rf_options.py (with extend- prefix rewriting for extend-* variants) and regenerate model.py and config.md.

• contributing: Add agent workflow guide and update contribution guide (9a024a2)
• contributing: Clarify DCO vs GPG signing and unify branding (a1f116d)

Reference the DCO in the CONTRIBUTING Legal Notice and recommend git commit -s. Clarify in both places that the DCO sign-off is separate from the GPG/SSH commit signature (git commit -S) required for merges.

In AI_POLICY.md, drop the duplicated DCO statement and link to the Legal Notice instead. Align the PR template's tests/lint/signed-commits bullets with the CONTRIBUTING checklist, and unify the project name spelling to "RobotCode" across the three files (URLs and CLI names unchanged).

• contributing: Add AI policy and refine contribution guide (688e6ae)

Add a project-wide AI and Automated Contribution Policy (AI_POLICY.md) covering human responsibility, disclosure, low-context submissions, and enforcement.

Restructure CONTRIBUTING.md:

• new "Project-Wide Rules" section linking the AI policy and the payment/bounty rule
• add a pre-commit hooks section (uvx / uv tool install / pipx)
• mention uv / uvx alongside pipx for installing hatch
• rewrite the Running Tests section: `hatch run test:test` as the recommended default, correct RF versions (5.0–7.4) and matrix size (5×8=40), clarify that bare `hatch run test` only runs in the default env
• consolidate PR guidelines into a PR checklist + description + review process, referencing the new PR template
• fix TOC duplicates and the empty Payment link

Add a GitHub pull request template with checklist and AI/tooling disclosure block, and add the same disclosure block to the bug, enhancement, and question issue templates.

• home: Refresh landing page (8dc70e0)

Mirrors the reworked README pitch: tightened hero, consolidated feature cards, and a "Sponsor RobotCode" section with Individual/Corporate split.

Adds a RandomTagline component, analogous to RandomHeroImage, so the hero tagline rotates randomly on each page load.

• news: Add v2.6.0 release notes (7d6a701)

• readme: Restructure and refresh (69c881b)

• Sharpen What-is intro with Foundation / Core-Team partnership note

• Restructure Key Features into Editor/IDE, Configuration, Command line groups with marketing-oriented bullets
• Tighten Requirements (correct VS Code 1.108 / IntelliJ 2025.3, prominent LSP-editor note)
• Add Command Line installation block for CI / non-IDE users
• Fix broken doc links (troubleshooting page never existed, /support/ → /05_contributing/)

• Split Sponsor RobotCode and Get Involved into separate sections

• repl: Clarify REPL scripts are body-only .robotrepl files, not full suites (a169d86)

Reword the file-execution section so it no longer implies a full .robot suite can be run. These inputs are REPL scripts — a test-case body only, with no *** Settings *** / *** Test Cases *** sections — and use the .robotrepl / .robotscript extension instead of .robot. A file with section headers fails with "No keyword with name ' Settings ' found"; import libraries and resources from inside the body with Import Library / Import Resource.

Also note that .save only guarantees the export parses cleanly — REPL-only variables like ${_} still need an edit to run standalone — and tidy up wording, hyphenation, and a duplicated shortcuts list.

• repl: Document the prompt-toolkit extra (2660b7b)

New section in the REPL reference covers:

• the prompt-toolkit extra (pip install 'robotcode-repl[prompt-toolkit]') and the upgrades it lights up — live as-you-type candidate popup, fish-style auto-suggest, Ctrl-R reverse search UI, bracket auto-match, multi-line cursor movement
• the threaded completer + session cache that keep the popup responsive even with hundreds of importable modules on sys.path
• the fact that history is shared on disk between backends, so swapping extras doesn't lose arrow-up recall

• the [prompt-toolkit,gnureadline] combined extras as a sensible setup for libedit-backed Pythons

• repl: Document history persistence and tab completion (1374da7)

New "Prompt features" section in the REPL reference covers:

• where the history file lives (project .robotcode_cache/ vs. the per-user cache directory, ROBOTCODE_CACHE_DIR override), how the fish-style dedup behaves, and the --no-history / ROBOTCODE_REPL_NO_HISTORY / ROBOTCODE_REPL_HISTORY_SIZE escape hatches
• what Tab completes — keywords from loaded libraries and imported resources, suite-scope variables (${...} / @{...} / &{...}), %{...} environment variables, and the three Import arguments with plain / dotted / filesystem prefixes
• the gnureadline extra for macOS' system Python and python-build-standalone interpreters (uv / rye / …) where the stdlib readline is libedit-backed and Tab would otherwise be degraded

Also adds the REPL reference to the index page.

• repl, repl-server: Correct misleading --source help text (87402e3)

The flag only uses the parent directory of FILE as the REPL's working directory — it does not read or write the file, and does not set a suite name.

• runner: Task-oriented guide for robotcode discover (f69fd9a)

A new discovering-tests.md page covers the discover family the same way analyzing-results.md covers results. It walks every subcommand from the terminal perspective — all, tests, tasks, suites, tags, files, info — with examples and flag tables, then the shared Robot-native filters and --search / --search-regex behaviour, and finally the full JSON schema reference for scripts, CI pipelines, and editor integrations (TestItem, ResultItem, TagsResult, Info, diagnostics, filtersApplied) plus a set of jq-based CI recipes for sharding, tag reports, and parse-error gates.

• runner: Cover extended search and results log --keyword-info / --suite-info (a7395f6)

• analyzing-results.md: search-target list mentions test doc/template/timeout, keyword [Documentation]/[Tags]/[Timeout] (result-tree-only), and ancestor-suite Documentation/Metadata. New --keyword-info and --suite-info subsection explains what each flag adds to TEXT and JSON, with a combined example. log JSON schema shows the new suites array and per-test suite cross-reference plus a table for the keyword doc/tags/timeout fields.

• cli.md: regenerated from hatch run create-cmd-line-docs to pick up the new --keyword-info / --suite-info flags on results log and the updated --search help text across results and discover.

• runner: Fix "releative" typo in discover --help (eeb8979)

• website: Use bundler module resolution (dd6f358)
• website: Improve hero image navigation (09a8975)
• Split REPL reference into shell and command-line debugger pages (7f0577f)

The REPL reference mixed the interactive shell with the command-line debugger. It is now two pages:

• "Interactive Robot Framework with robotcode repl" — the shell.
• "Command-line debugging with robotcode robot-debug" — a dedicated page for the debugger: ways to pause a run (line, keyword, embedded Breakpoint keyword, exceptions, stop-on-entry), the debug command set (stepping, call stack, inspecting and setting variables, breakpoint management, exception filters, log-and-continue), a worked example with the embedded Breakpoint keyword, and how it relates to the VS Code debugger.

Other improvements:

• Each command reference page now states which optional package to install to run it: robotcode[repl], [runner], or [analyze].
• The CLI reference now documents robotcode robot-debug (alias run-debug) and lists it under the repl package.
• Fixed the .doc command description: it shows documentation for libraries and resources the session has imported, not on demand.
• Add "Working with AI Agents" reference page (e7c8d68)

Describe how RobotCode lets AI coding agents work through the project's own robotcode CLI instead of guessing:

• the chat plugin (a skill) and what it teaches the agent — discover, libdoc, REPL, results, analyze on the resolved project
• the bundled VS Code plugin and its enableChatPlugins toggle, plus the extension shipping the robotcode CLI on the integrated terminal PATH
• installing the plugin in other agents via the Open Plugins marketplace
• recommended project-context setup (AGENTS.md / CLAUDE.md): environment, library init steps, the system under test, conventions
• the CLI's AI-agent detection and its override env vars/flags
• troubleshooting

• Refine contribution guide and AI policy (b93cbf6)

• AI_POLICY: welcoming, principle-led intro; clarify that what matters is human ownership, not whether an autonomous agent was involved; frame the purpose around protecting maintainer time, which is what ultimately keeps RobotCode sustainable

• CONTRIBUTING: add a "find your path" orientation block and a warmer Project-Wide Rules intro; lead commit-signing setup with the low-effort SSH path; document that documentation-only changes need neither the test matrix nor linting (there is no Markdown linter); remove decorative emoji
• PULL_REQUEST_TEMPLATE: mark the tests and linting checks N/A for documentation-only / non-code changes
• Add results analysis guide (ebb2d12)

A task-oriented user guide for the robotcode results family of commands, split into two parts:

• Using the commands — what each subcommand does in the terminal, its useful flags, sort/filter semantics, and the pager / colour handling. Recipes for the common day-to-day questions: "what failed", "which test took longest", "drill into one test", "regression vs main".
• JSON reference — schema rules (omitted vs null vs []), per-subcommand JSON shape, the body-item-type vocabulary used by log, the filtersApplied echo, and CI/jq recipes for pass-fail gates, slow-test reports, notification payloads and artefact gathering. Includes a note specifically for AI-driven workflows on why streaming the focused JSON beats parsing raw output.xml.

Also linked from the reference index page.

• Update json schema for robot.toml validations (6d4fd6d)

Performance

• vscode: Smoother test explorer refreshes and live test updates (bc488d0)

The Test Explorer used to flicker on every keystroke when the tree was expanded, slow to a crawl during multi-file edits (e.g. when an AI agent applies many edits at once), and sometimes show "AbortError" as a workspace entry at startup. Newly added or removed tests didn't appear in the tree until the refresh button was pressed.

What's different now:

• The tree only re-renders when the discovered tests actually change; identical re-discoveries leave the UI untouched.
• One refresh runs at a time — newer edits cancel the in-flight subprocess instead of queuing up behind it.
• Many edits in a short window collapse into a single workspace refresh.
• External file changes no longer collapse expanded tree nodes.
• Tests added or removed in a saved file appear/disappear immediately.
• A workspace refresh no longer runs a redundant per-document discover for every open file.

Also fixes a non-deterministic tag order from the discover command so the TS side can reliably detect real tag changes.

Refactor

• diagnostics: Unify number-literal detection helpers (4dcb22f)

Replace the direct robot.variables.finders.NumberFinder dependency and the two duplicated _try_resolve_number_literal static methods with shared try_resolve_number_literal / is_number_literal helpers in robot.utils.variables, consumed from model_helper, namespace_analyzer and the semantic analyzer.

• language-server: Pure SemanticModel for signature help and code action (2a4e728)

Both LSP feature paths now read everything off the SemanticModel — no RF AST walks, no ModelHelper position helpers. SemanticToken carries a precomputed LSP Range so consumers can use native operators (pos in tok.range, range in tok.range, tok.range.extend(...)) instead of per-coordinate arithmetic. Output unchanged.

• repl: Unify the setting-alias flag and tidy completion internals (c3d50fe)

Review follow-up, no behaviour change:

• Use one name, setting_import_aliases, for the flag everywhere (it was include_setting_aliases on candidates_for_rich).
• Make _RobotCompleter's flag public so the _smart_tab key binding reads it off the active completer without reaching into a private attribute.
• Move the assignment-target helpers above their first caller so there is no forward reference.

• Add completer-level tests: the >>> completer forwards the flag into the candidate service, and Tab after a setting alias opens completion instead of inserting a cell separator.

• runner: Extract discover data models and align info JSON casing (95c119b)

The TestItem / ResultItem / Statistics / TagsResult / Info classes move out of discover.py into a dedicated _models.py, matching the layout the results family already uses. discover.py imports them from there, keeping the command file focused on click wiring and traversal.

Info was the only discover model without CamelSnakeMixin, so discover info was emitting robot_version_string / python_version_string / system_version / robot_env while every other discover and results JSON key was already camelCase. It now uses the mixin too, so -f json discover info (and the TEXT key:value rendering) speaks the same robotVersionString / pythonVersionString / systemVersion / robotEnv shape as the rest. Tests and the reference docs follow.

• runner: Adopt SuiteVisitor for body traversal in _search (000f2e9)

Replace _body_matches' manual recursion + string-based item.type dispatch with a SuiteVisitor subclass that overrides one start_X per body-item type. Robot's own visitor handles the recursion; returning False from each hook short-circuits the rest of the traversal once a match is found.

This drops every getattr in the file: the fully-qualified keyword name comes from the inherited Keyword.name property (which already composes libname.kwname on RF <7 result trees), result-tree-only .message is guarded with isinstance(item, StatusMixin), template (running-model only) is guarded with isinstance(test, RunningTestCase), and the For.assign vs For.variables rename is handled by one top-level RF_VERSION gate. RF 7+ Var/Group/Error types come in via a TYPE_CHECKING import with # type: ignore[attr-defined,unused-ignore].

As a side-effect Error.values is now part of the searched fields — the old type-string dispatch silently skipped Error items.

• runner: Adopt ResultVisitor for body traversal in results (5e5c88f)

Replace manual body recursion (_collect_test_body's build-pattern and _count_all_messages' inline walk) with ResultVisitor subclasses that override the per-type end_X methods Robot's dispatch already provides. This removes the string-based item.type checks, eliminates the remaining getattr calls on stable Robot attributes, and lets every body item flow through one well-typed code path.

Side cleanups in the same pass: hoist RF-version-conditional access (kwname/libname vs name/owner, For.assign vs For.variables, Result.elapsed_time vs elapsedtime, StatusMixin time fields) into top-level helpers gated on RF_VERSION, switch the Var/Group/Error imports to a TYPE_CHECKING-only # type: ignore[attr-defined,unused-ignore] form, and drop _eval_str — the profile is already evaluated before it reaches this code, and StringExpression.__str__ covers the rest.

• runner: Drop more Any from results.py (15 → 6) (8b4f059)

Three more rounds of tightening on top of the previous pass:

• _eval_str / _iso accept object (we use generic isinstance / getattr / str() on them, no type-specific access).
• _make_message_entry takes Message — it's only called for MESSAGE-typed body items, so the static type is precise.
• _start_time / _end_time now return Optional[object] (forwarded unchanged to _iso, which accepts object).
• The four RF-version-gated helpers (_iter_all_tests, _get_full_name, _keyword_name_and_owner, _loop_variables) get proper TestSuite / TestCase parameters where the polymorphism isn't on the input type. Internally they use getattr for the attributes whose existence depends on the runtime RF version, so mypy stays happy across the whole RF matrix without # type: ignore. Same behaviour, just less guesswork at call sites.

Any remains on the six positions where it's the only honest answer: the heterogeneous body-item helpers (_keyword_name_and_owner, _loop_variables, _elapsed_seconds, _start_time, _end_time, inner build). Each item type carries different attributes; we dispatch by type string and getattr. Typing them as a Union of 9+ result-tree classes would be heavier than the type safety it provides.

• runner: Replace Any with proper Robot types in results.py (e70314f)

Twenty-one stable-API positions get real type hints. Any survives only where it's genuinely the right answer:

• The four RF-version-gated helpers (_iter_all_tests, _get_full_name, _keyword_name_and_owner, _loop_variables) — each branch accesses attributes that exist only on the matching RF version, and mypy sees only the installed one.
• Body-item helpers and the inner build(item) in _collect_test_body — body items are a Keyword | For | If | Try | While | Var | Return | Group | Message union and we dispatch by getattr(item, "type").
• _elapsed_seconds / _start_time / _end_time — called on suites, tests and keywords; truly polymorphic.
• _iso, _eval_str, msg — string-or-something accepting helpers.

For everything else, the actual Robot class lands in the signature: TestSuite and TestCase from robot.result, Result for the loaded execution result, ExecutionErrors for the errors collection, RobotBaseProfile for the resolved profile, and SuiteVisitor for the modifier list. No behaviour change; mypy is happy on every RF version in the matrix.

• runner: Collapse results filter pipeline into a single pass (93c3cf6)

Every results subcommand used to filter twice: first delegating include/exclude/suite/test to TestSuite.filter() via _apply_tree_filters, then re-walking the (still-full) tree inline to apply --status and --search. The matcher and the status-set lived in each command body; helpers like _collect_counts / _collect_failures took the matcher and status filters as parameters.

Collapse that into one pre-pass and one pre-pass only:

• Add a ByStatus SuiteVisitor in _search.py (Robot has no native status filter, so this stays ours, but in the same shape as ByLongName / SearchModifier).
• Extend _apply_tree_filters to also accept status_filters and the search matcher, bundling every project-specific filter into a single ModelModifier pass that visits the tree once.
• After the pre-pass, every surviving test has cleared every filter, so _collect_counts and _collect_failures shrink to a plain tally / [t for t in suite ... if t.status == "FAIL"]. The _normalise_statuses / _raw_test_search_matches helpers and the _STATUS_KEY_MAP constant lose their last callers and go away too.

• One subtle behaviour shift: search now matches test.name and test.longname separately (via SearchModifier), where the old _raw_test_search_matches only saw the full name. That's a strict superset — an anchored regex like ^Pass.* now matches a test literally named Passing Test Three. Updated test_search_regex_anchors_and_alternation to pick a pattern that matches no field instead of relying on the old narrower contract.

• runner: Polish results stats UX and docstrings (36e3996)

• --by now displays the actual choices ([tag|suite|status]) in --help instead of the placeholder DIMENSION metavar, so the allowed values are discoverable without reading the docs.

• stats --by suite groups by the suite's full name (e.g. MyProject.Login) rather than the bare leaf name. Suites that share an end name in different parts of the tree are now distinguished.

• Drop internal report.html / "Mirrors X" justifications from user-facing docstrings — that's plan-rationale, not help text.

• tests: Standardize on pytest-mock and shared analyzer fixtures (441618c)

Replaces direct unittest.mock usage with the project's existing pytest-mock convention so tests are stricter (autospec) and new tests need less boilerplate.

• Drop three orphaned private symbols (38a7995)

Dead code surfaced by an unused-symbol sweep across packages/:

• _BRANCHES (repl/_indent.py): a frozenset that was only there to document which Robot keywords (ELSE, ELSE IF, EXCEPT, FINALLY) the indent counter ignores. Replaced with a short inline comment — same self-documenting effect, no orphan symbol.
• _split_comma (analyze/code/cli.py): a click callback added alongside the --xm / --xe exit-code-mask options, then superseded by _parse_exit_code_mask and never wired up.
• _cancel_all_running_tasks (core/concurrent.py): originally the public cancel_running_callables; the FutureEx → Task rename privatised it but no caller followed.