Features

• robot: Make the analysis cache trustworthy under rapid file changes (c998399)

  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)

  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.

Bug Fixes

• plugin: Use compact JSON separators for json output format (e882368)

  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)

  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)

  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)

  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)

  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).

Documentation

• news: Add v2.7.0 release notes (033e12d)

  Announce the test-run wrapper, the trustworthy analysis cache, and the
  restored -I/-N options for Test Explorer subset runs.

Bug Fixes

• vscode: Refresh the Test Explorer after a language server restart (0098190)

  • test items and run buttons no longer vanish until a window reload after a restart
  • a folder's tests are re-discovered when its language server restarts
  • run profiles are rebuilt once per restart instead of on every state change
  • a test run no longer hangs when a debug session fails to start
  • cancelling a run stops only that run, and works while it is still starting
  • a fixed error clears its decoration; stale diagnostics are cleared on an invalid environment
  • per-folder refresh, so one folder no longer interferes with another

Documentation

• news: Cover v2.6.2 alongside v2.6.1 in the release notes (5beabad)
• news: Add v2.6.1 release notes (3e1be81)

Bug Fixes

• langserver: Prevent inconsistent Robocop formatting (e31ed32)

  Formatting a file with Robocop repeatedly no longer oscillates between states (for example a blank line being added and removed before a section header on every other format). The formatter mutated the shared, cached document model in place; it now works on a fresh, uncached model so repeated formatting stays idempotent.

• robot: Recover automatically from a corrupt cache database (2ec7a9c)

  The workspace cache database could become corrupt ("database disk image
  is malformed"). Once that happened nothing recovered: restarting the
  language server kept failing while opening the cache, and "Clear Cache
  and Restart Language Servers" failed too because it cleared entries
  through the already-damaged database.

  RobotCode now detects a corrupt cache database, discards it (including
  its -wal/-shm sidecars) and rebuilds it from scratch, so the keyword
  view, test discovery and the clear-cache command keep working without
  any manual cleanup. If the file cannot be removed or reopened (for
  example while another editor window holds it open), it falls back to a
  temporary in-memory cache for the session instead of failing to start.

  Access to the cache is now serialized so it stays consistent under the
  language server's concurrent requests, and memory-mapped reads are
  disabled on macOS, where they could leave a corrupt page behind.

• vscode: Drop selected profiles that no longer exist in the config (e3bad18)

  When a profile was selected and then removed from robot.toml — for
  example after switching git branches — the selection stayed active.
  This produced a "profile not found" error on every test run, and the
  profile could not be deselected because the selection menu refused to
  open when no profiles were left to choose from.

  Now opening "Select Configuration Profiles" removes any selected
  profile that is no longer defined in the configuration and shows a
  message listing which profiles were removed. If the available profiles
  cannot be determined (e.g. an invalid environment), the current
  selection is left untouched.

• Don't pull html-to-markdown into the 'all' extra (6bf2a6d)

  Since version 2.0 html-to-markdown ships as a Rust extension with prebuilt wheels only for a limited set of platforms (manylinux x86_64/aarch64, macOS, win_amd64). On other targets such as 32-bit Raspberry Pi OS (armv7l) or Alpine/musllinux, pip falls back to a source build that needs a Rust toolchain and fails, which broke 'pip install robotcode[all]'.

  html-to-markdown only improves HTML log conversion in the 'results' command and has a built-in stdlib fallback, so it is now opt-in via 'pip install robotcode-runner[html]'.

Documentation

• ai-agents: Foreground the debugger over the REPL (0c40394)

  Make robot-debug the primary tool for working with a real test and
  the REPL the narrower fallback for exploring when no test exists yet.
  Add debugger examples, a debugger-first core-habit entry, a
  troubleshooting item for chasing a failing test instead of debugging
  it, and note that agent output capture and the plain backend apply to
  robot-debug too.

• Add reference page for excluding files with .robotignore (d8990ec)

  Documents the .robotignore file: gitignore-style syntax, how it relates to .gitignore (it replaces it rather than merging), nested files, what RobotCode skips by default, where it applies (discovery, analysis, and the language server), how to verify the result with robotcode discover files, and how to use it to speed up analysis on large projects.

  Also links the new page from the discover files reference.

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](https://github.com...

Bug Fixes

• analyzer: Do not report embedded arguments as VariableNotFound in template keywords (c34455f)

  When a test case uses [Template] or Test Template with a keyword that has
  embedded arguments (e.g. "The result of ${calculation} should be ${expected}"),
  the embedded argument placeholders were incorrectly analyzed as unresolved
  variables, producing false VariableNotFound diagnostics.

  Skip variable analysis for embedded argument tokens when the keyword call
  originates from a template declaration.

• robot: Match longest BDD prefix first for multi-word prefixes (dad536e)

  French BDD prefixes like "Étant donné que", "Et que",
  "Mais que" were not fully recognized because shorter prefixes (e.g.
  "Et") matched before longer ones (e.g. "Et que").

  Replaced manual iteration and set lookups with a regex-based approach
  matching Robot Framework's own strategy: prefixes sorted by length
  (longest first), compiled into a cached regex pattern. This applies to
  keyword_finder, model_helper (split/strip/is_bdd), and semantic tokens.

• robot: Fix ${CURDIR} replacement in variable values and unify handling (13bf36b)

  Extract replace_curdir_in_variable_values() helper into utils/variables.py
  to deduplicate the ${CURDIR} substitution logic from _MyResourceBuilder and
  NamespaceAnalyzer. Fixes incorrect double-backslash escaping in
  _MyResourceBuilder that caused ${CURDIR} resolution to fail on Windows.

Documentation

• news: Add v2.5.1 release notes (b0d9fb9)

Refactor

• diagnostics: Add debug logging for namespace cache misses (99e322d)

  Log specific reasons when namespace cache entries are invalidated,
  including source mtime changes, config fingerprint mismatches, and
  dependency changes (libraries, resources, variables). Uses debug
  level with context_name="cache" for targeted activation.

Bug Fixes

• robot: Strip trailing = from variable names in resource builder (e11ca60)

• robot: Do not override the source on a model if there is already a source field (7e74c2d)

  Newer Robot Framework versions already set the source field on File AST blocks, so overriding it here is unnecessary.

• robot: Resolve relative library paths in namespace cache validation (45d8f9f)

  Namespace cache validation failed for files importing libraries via
  relative paths (e.g. ../../resources/libraries/common.py), causing
  unnecessary full rebuilds on every warm start.

  Two issues fixed:

  • validate_namespace_meta now passes the source file's directory as
    base_dir when falling back to get_library_meta/get_variables_meta,
    so relative paths resolve correctly
  • get_library_meta and get_variables_meta initialize import_name
    before the try block to avoid UnboundLocalError when find_library
    or find_variables fails

• robot: Correct check for init.py file in _is_valid_file function (ffad219)

• robot: Add lock for _workspace_languages to prevent race condition (9bf0ee6)

  WeakKeyDictionary is not thread-safe for concurrent read/write.
  Protect all access to _workspace_languages with a dedicated RLock.

Documentation

• news: Add supplementary release note for v2.5.0 (a8c39a3)

• Update release notes for v2.5.0 with (9978a88)

• Add news section to documentation site (7f14925)

  Add a dedicated news section for release announcements with
  auto-generated sidebar (sorted newest-first), content loader,
  and redirect from /news/ to the latest article.

Features

• analyze: Add cache management CLI commands (1421107)

  Add robotcode analyze cache subcommand group with five commands:

  • path: print resolved cache directory
  • info: show cache statistics with per-section breakdown
  • list: list cached entries with glob pattern filtering (-p)
  • clear: remove cached entries by section
  • prune: delete entire .robotcode_cache directory

  Output adapts to the global --format flag (text/json/toml) and
  --no-color mode. Text output uses rich-rendered markdown tables
  when color is enabled, plain aligned tables otherwise.

• analyze: Enable namespace caching by default (d896213)

  Namespace caching speeds up startup for large projects by skipping
  re-analysis of unchanged files. It is now mature enough to be enabled
  by default.

• analyze: Add --cache-namespaces/--no-cache-namespaces CLI option (b050c32)

  Add option to enable/disable caching of fully analyzed namespace data
  to disk. Disabled by default until the cache is fully optimized and
  validated. When enabled, skips re-analysis of unchanged files on
  startup, which can significantly speed up large projects.

  Available as CLI flag (--cache-namespaces/--no-cache-namespaces),
  robot.toml setting (tool.robotcode-analyze.cache.cache_namespaces),
  and VS Code setting (robotcode.analysis.cache.cacheNamespaces).

• analyze: Add collection of unused keywords and variables on the CLI (5734690)

  Add support for collecting unused keyword and variable diagnostics when
  running robotcode analyze code from the command line.

  The feature can be enabled in robot.toml:

  [tool.robotcode-analyze.code]
  collect-unused = true

  or controlled directly per invocation:

  robotcode analyze code --collect-unused
  robotcode analyze code --no-collect-unused

• langserver: Add code completion for Literal type hint values (42ab3a0)

  Keywords with Literal["fast", "slow", "auto"] type hints now show
  their allowed values in the completion list, making it easier to
  discover and select valid argument values without checking the
  keyword documentation.

  Also supports Union types containing Literal, e.g.
  Union[Literal["x", "y"], int].

• language_server: Add json to watched file extensions (74e92b0)

• plugin: Add has_rich property to detect rich availability (4581cc6)

  Fall back to plain-text output in cache CLI commands when the rich
  package is not installed, instead of dumping raw unformatted markdown.

• robot: Add ROBOTCODE_CACHE_DIR env var for cache path override (a778cd5)

  Enable redirecting the analysis cache to a custom directory via the
  ROBOTCODE_CACHE_DIR environment variable. This allows all RobotCode
  tools — CLI commands, analyze runs, and the language server — to
  share the same cache regardless of where it is stored.

  The VS Code extension automatically sets this variable in the
  integrated terminal, so CLI commands find the correct cache
  without any manual setup.

  Cache clearing now operates on the database directly instead of
  removing the directory, preventing errors when multiple processes
  access the cache concurrently.

• robot: Add advisory file locking to SQLite cache (b9351fc)

  Add shared/exclusive advisory file locking (fcntl.flock) to prevent
  prune from deleting a cache database while another process (language
  server, analyze run) is using it.

• robot: Add SQLite cache backend for library and namespace data (edaea47)

  Replace file-based pickle caching with a single SQLite database per
  workspace, consolidating all cache entries into one file instead of
  many individual .pkl files scattered across directories.

• robot: Add namespace disk cache for cold-start acceleration (abf3387)

  Speed up first-time file analysis by caching fully resolved
  namespace results to disk. On subsequent IDE starts, cached
  namespaces are reused instead of re-analyzing every file from
  scratch, significantly reducing the time until diagnostics,
  code completion, and navigation become available.

  The cache is automatically invalidated when source files,
  library dependencies, environment variables, command-line
  variables, language configuration, or the RobotCode version
  change.

• robot: Add ProjectIndex for O(1) workspace-wide reference lookups (6ef90f1)

  Add an incrementally maintained inverse reference index (ProjectIndex)
  scoped per WorkspaceFolder. On each file build, references are updated
  in-place instead of scanning all files. All six reference types are
  supported: keywords, variables, namespace entries, keyword tags,
  testcase tags, and metadata.

• robot: Track tag and metadata references in namespace analysis (6a372fe)

  Add structured reference tracking for tags and metadata during analysis.
  Tags are split into keyword_tag_references and testcase_tag_references
  to reflect their different semantics in Robot Framework (keyword visibility
  vs test selection/reporting). Metadata references track settings-level
  metadata entries by key. All reference keys are normalized for consistent
  lookups. Remove unused TagDefinition class.

• settings: Remove deprecated robocop configuration options (fa2217e)

• vscode: Show "What's New" notification after extension update (7fb2071)

  Display an info notification when the extension version changes,
  linking to the news page on robotcode.io via the built-in Simple Browser.
  Also adds a public "RobotCode: Show What's New" command to the palette.

Performance

• cache: Defer data blob loading in CacheEntry until first access (795c420)

• diagnostics: Remove redundant exists() check in get_resource_meta (5696868)

• diagnostics: Consolidate to single AST model and remove data_only parameter (e2e4cbd)

  This eliminates the second cached AST model per document, saving ~500KB/doc
  in...

Bug Fixes

• dependencies: Update click version to 8.2.0 in requirements files (6e1220e)

• vscode: Fix invalid glob pattern in selectConfigurationProfiles (58b5a8f)

  Remove extra closing brace in the file extension glob pattern that
  caused workspace folder detection to fail when selecting configuration
  profiles.

Features

• plugin: Add fast exit option to Application.exit method (acfa7e9)

Performance

• diagnostics: Skip full AST model parsing when no robotcode: markers present (7b3999e)

• robot: Cache LibraryDoc for robot and resource files on disk (9b89623)

  Resource and robot files are now cached on disk between sessions.
  On subsequent opens, imports, keywords, and variables from these
  files are loaded from cache instead of being re-parsed, resulting
  in faster startup and quicker response times when navigating
  projects with many resource files.

  The cache is automatically invalidated when a file is modified
  on disk. Files that are currently open in the editor always use
  the live content and bypass the disk cache.

• robot: Remove unnecessary token list caching from document cache (5f8591d)

  Token lists were cached separately in document._cache, but only used
  as intermediate input for AST model building. No external caller ever
  accessed the cached token lists directly.

  Move token generation into model builder methods so tokens are only
  produced on cache miss. On cache hit, neither tokenization nor model
  building occurs.

  • Eliminates up to 6 cached token lists per document in Language Server
  • No behavior change for CLI (tokens were already uncached for version=None)
  • Remove ~80 lines of redundant caching infrastructure

• robot: Use file_id tuples instead of os.path.samefile for path comparison (3f3bd84)

  Replace repeated os.path.samefile() calls (2x stat per call) in namespace
  import loops with pre-computed (st_dev, st_ino) tuple comparisons.

  • Add FileId type, file_id() and same_file_id() to core utils
  • Add lazy source_id property to LibraryDoc (excluded from pickle)
  • Pre-compute source_id on Namespace init
  • Compute file_id once per find_resource result instead of per-iteration

Refactor

• imports_manager: Cleanup and fix correctness issues (25ef49c)

• robot: Remove unnecessary finalizers and dispose chain (eaa7e14)

  Remove redundant _release_watchers_finalizer from _ImportEntry — file
  watcher cleanup is already handled explicitly by _remove_file_watcher()
  during invalidation and by server_shutdown() at LS shutdown.

  Remove the _dispose_finalizer/dispose() chain through ImportsManager,
  DocumentsCacheHelper, RobotFrameworkLanguageProvider, CodeAnalyzer, and
  CLI. With the per-entry finalizers gone, these only cleared dicts that
  Python already cleans up at process exit.

  Fix broken finalizer in Workspace.add_file_watchers() where the closure
  captured the entry object, preventing it from ever being garbage
  collected.

  Set atexit=False on sentinel finalizers so they only fire during normal
  GC (needed for LS live cleanup), not at interpreter shutdown.

• robot: Replace del with weakref.finalize in imports_manager (e0e8d81)

  Replace fragile __del__ methods with weakref.finalize in both
  _ImportEntry and ImportsManager for reliable cleanup:

  • _ImportEntry: register finalizer in init with file_watchers list
    and file_watcher_manager as strong refs (no self access needed);
    change _remove_file_watcher to use .clear() instead of = []
  • ImportsManager: register finalizer lazily in executor property when
    ProcessPoolExecutor is created; add static _shutdown_executor callback

  weakref.finalize is guaranteed to run even with circular references
  and does not prevent garbage collection of reference cycles.

Testing

• Add library folder to test project (45c410f)

Bug Fixes

• langserver: Update version check for Robocop in formatting and diagnostics parts (45655f4)

Documentation

• tips-and-tricks: Make LSP config OS independent (e1abda2)

  More robust implementation of get_python_path helper function.

• tips-and-tricks: LSP setup guide for Neovim (c63c125)

Features

• robocop: Robocop 8.0 support (f723d98)

Bug Fixes

• intellij: Add missing language method in RobotCodeCodeStyleSettingsProvider (90673bf)

• langserver: Default to folding ranges to character-based (6cbefe2)

  Use character-based folding ranges by default when client capabilities are unknown.

• robocop: Update robocop documentation urls (c15bdfa)

• robot: Use explicit class reference for super() in VariablesDoc to allow slots (8af05a9)

Documentation

• Add some funny random hero images (f62e1bd)
• Back to normal hero image (57633b5)

Features

• Add support for Robot Framework 7.4 (3e140c9)
• Enhance diagnostics and analysis features with progress indicators in verbose mode and performance improvements (1ac9247)

Performance

• lsp: Use dataclass slots for protocol types (82012e8)

  use @DataClass(slots=True) for LSP model classes to reduce per-instance memory overhead and speed up attribute access in LSP hot paths

Refactor

• core: Simplify casing caches and add support for PEP 604 unions (428226a)
• Reduce lru_cache maxsize for performance optimization across multiple modules (f715d32)

Testing

• Real pyproject file for test project (c3e17b2)