docs(news): add supplementary release note for v2.5.0

Author: d-biehl

docs/news/2026-03-31-whats-new-v2.5.0.md

@@ -5,15 +5,15 @@ date: 2026-03-31
 
 # What's New in RobotCode v2.5.0
 
-If you've ever opened a large Robot Framework project and gone for coffee while RobotCode was still thinking — this release is for you. Version 2.5.0 is all about **speed**: faster startup, faster analysis, faster code completion. And a few new tricks on top.
+If you've ever opened a large Robot Framework project and gone for coffee while **RobotCode** was still thinking — this release is for you. Version 2.5.0 is all about **speed**: faster startup, faster analysis, faster code completion. And a few new tricks on top.
 
 ## Instant Startup with Analysis Caching
 
 The biggest change you'll notice: **RobotCode remembers**. When you open a project for the second time, all the analysis work from your last session is still there — diagnostics, code completion, navigation, everything loads almost instantly.
 
-Behind the scenes, RobotCode now stores fully resolved analysis data in a local SQLite database. Instead of re-analyzing every file on every IDE start, it loads cached results and only re-processes files that actually changed. For projects with hundreds of Robot files, this can cut startup from minutes down to seconds.
+Behind the scenes, **RobotCode** now stores fully resolved analysis data in a local SQLite database. Instead of re-analyzing every file on every IDE start, it loads cached results and only re-processes files that actually changed. For projects with hundreds of Robot files, this can cut startup from minutes down to seconds.
 
-This is **enabled by default** — there's nothing to configure. The cache is automatically invalidated when your source files change, when library dependencies are updated, when environment variables or command-line variables differ, or when you update RobotCode itself. If something changes, the affected parts are re-analyzed — everything else comes straight from cache.
+This is **enabled by default** — there's nothing to configure. The cache is automatically invalidated when your source files change, when library dependencies are updated, when environment variables or command-line variables differ, or when you update **RobotCode** itself. If something changes, the affected parts are re-analyzed — everything else comes straight from cache.
 
 Since this is a new feature, you can disable it if you run into any issues:
 
@@ -35,27 +35,27 @@ Multiple processes (the language server, CLI commands, parallel analyze runs) ca
 
 Even without the cache, this release is noticeably faster. Here's what changed:
 
-- **No more 30-minute hangs on large projects.** Robot Framework's `variable_not_found` runs a fuzzy "Did you mean…?" search on every unresolved variable — a nice idea, but O(n×m) over all variable candidates. For big projects (375+ files), this could freeze the analysis for over 30 minutes. RobotCode now skips that search entirely since it never uses the suggestion text. Problem solved. ([#587](https://github.com/robotcodedev/robotcode/issues/587))
+- **No more 30-minute hangs on large projects.** Robot Framework's `variable_not_found` runs a fuzzy "Did you mean…?" search on every unresolved variable — a nice idea, but O(n×m) over all variable candidates. For big projects (375+ files), this could freeze the analysis for over 30 minutes. **RobotCode** now skips that search entirely since it never uses the suggestion text. Problem solved. ([#587](https://github.com/robotcodedev/robotcode/issues/587))
 
 - **Keyword matching is 94% faster.** The `KeywordMatcher` used to be instantiated from scratch on every lookup — about 7.5 million times per analysis run. It's now cached on the `KeywordDoc` itself. Combined with a new dict-based index in `KeywordStore`, keyword lookups went from linear scan to O(1) for non-embedded keywords. Overall analysis time dropped by **22%** with **31% fewer function calls**.
 
 - **File resolution is 28% faster.** Swapping `pathlib.Path` for `os.path` string operations in the hot path of file resolution plus lazy-caching of valid `sys.path` entries cut warm-start wall time by nearly a third.
 
 - **Less memory per document.** Each document used to keep two cached AST models. Now there's just one, saving around 200–500 KB per file. That adds up quickly in a big workspace.
 
-- **Faster cache loading.** Cached namespace data now includes source hints that let RobotCode skip expensive filesystem lookups (`find_resource`) when the cached paths still exist on disk. Cache entries use lazy deserialization — data blobs are only unpickled on actual cache hits, not on every lookup.
+- **Faster cache loading.** Cached namespace data now includes source hints that let **RobotCode** skip expensive filesystem lookups (`find_resource`) when the cached paths still exist on disk. Cache entries use lazy deserialization — data blobs are only unpickled on actual cache hits, not on every lookup.
 
 - **`ArgumentSpec.resolve()` actually caches now.** A subtle bug caused `RobotArgumentSpec` to be recreated on every call (100K times per run) instead of being cached. Fixed — instantiation calls dropped by **98.7%**.
 
 ## Smarter Code Completion for Type Hints
 
-If you write Python libraries with type hints like `Literal["fast", "slow", "auto"]`, RobotCode now picks up on those and shows the allowed values directly in the completion list. This works for `Union` types containing `Literal` too, so `Literal["x", "y"] | int` will offer `x` and `y` as suggestions.
+If you write Python libraries with type hints like `Literal["fast", "slow", "auto"]`, **RobotCode** now picks up on those and shows the allowed values directly in the completion list. This works for `Union` types containing `Literal` too, so `Literal["x", "y"] | int` will offer `x` and `y` as suggestions.
 
 No more switching to the library docs just to look up which string values a keyword accepts — the editor tells you right there.
 
 ## Find Unused Keywords & Variables from the CLI
 
-Unused keywords and variables are the kind of thing that quietly accumulates in any project. RobotCode can now detect them when running `robotcode analyze code` from the command line — great for CI pipelines or periodic cleanup sessions.
+Unused keywords and variables are the kind of thing that quietly accumulates in any project. **RobotCode** can now detect them when running `robotcode analyze code` from the command line — great for CI pipelines or periodic cleanup sessions.
 
 Enable it in your `robot.toml`:
 
@@ -91,14 +91,14 @@ You can also point the cache to a custom directory via the `ROBOTCODE_CACHE_DIR`
 
 - Fixed cache validation for libraries imported via relative paths — no longer triggers unnecessary full rebuilds on warm start.
 - Variable names with trailing `=` are now stripped correctly by the resource builder ([#546](https://github.com/robotcodedev/robotcode/issues/546)).
-- RobotCode no longer overrides the `source` field on AST blocks when Robot Framework itself already sets it ([#588](https://github.com/robotcodedev/robotcode/issues/588)).
+- **RobotCode** no longer overrides the `source` field on AST blocks when Robot Framework itself already sets it ([#588](https://github.com/robotcodedev/robotcode/issues/588)).
 - Fixed a race condition when accessing workspace language settings in multi-workspace setups.
 
 ## Under the Hood
 
 A lot of internal work went into this release to prepare for future features:
 
-- **Workspace-wide reference index (ProjectIndex)** — RobotCode now maintains an incrementally updated inverse index across your entire workspace. When a file changes, only its references are updated instead of scanning everything. This covers keywords, variables, namespace entries, keyword tags, testcase tags, and metadata. This is the foundation for upcoming features like unused import detection, import dependency visualization, and call hierarchy — stay tuned.
+- **Workspace-wide reference index (ProjectIndex)** — **RobotCode** now maintains an incrementally updated inverse index across your entire workspace. When a file changes, only its references are updated instead of scanning everything. This covers keywords, variables, namespace entries, keyword tags, testcase tags, and metadata. This is the foundation for upcoming features like unused import detection, import dependency visualization, and call hierarchy — stay tuned.
 
 - **Namespace refactoring** — The old monolithic `Namespace` class has been split into a clean data container (`Namespace` DTO) built by a dedicated `NamespaceBuilder`, with separate modules for import resolution, AST analysis, variable scoping, and scope trees. This makes the codebase more maintainable and easier to extend.
 

docs/news/2026-04-01-whats-new-v2.5.0.md

@@ -0,0 +1,159 @@
+---
+title: "v2.5.0: A Deeper Look at What's New"
+date: 2026-04-01
+sidebar: false
+aprilFools: true
+---
+
+<script setup>
+import { useRouter } from 'vitepress'
+import { onMounted } from 'vue'
+
+onMounted(() => {
+  const now = new Date()
+  const cutoff = new Date('2026-04-02T12:00:00')
+  if (now > cutoff) {
+    const router = useRouter()
+    router.go('/news/2026-03-31-whats-new-v2.5.0')
+  }
+})
+</script>
+
+# What's New in RobotCode v2.5.0
+
+Hello everyone,
+
+we're excited to share a big **RobotCode** release with you today. As many of you know, the main focus of v2.5.0 has been on performance — analysis caching, faster keyword resolution, smarter code completion. But while working on those features, we discovered some surprising opportunities that we just couldn't leave on the table. Here's the full picture.
+
+## Predictive Analysis Caching
+
+You already know that **RobotCode** now caches analysis results in a local SQLite database for instant startup. But we didn't stop there.
+
+The new **Predictive Caching** engine uses your git history, file modification patterns, and time-of-day statistics to pre-analyze files you're *likely* to open next. If you usually start your Monday mornings in the login test suite, **RobotCode** has those results ready before you even open the file.
+
+It also watches your keyboard idle patterns. Extended pauses after writing a `FOR` loop typically mean you're about to switch to a different file for reference — so **RobotCode** pre-caches the top 5 most probable navigation targets during those pauses.
+
+Configure prediction depth in `robot.toml`:
+
+```toml
+[tool.robotcode-analyze.cache]
+prediction-depth = "clairvoyant"  # options: "conservative", "optimistic", "clairvoyant"
+```
+
+## Proactive Performance Mode
+
+The performance improvements in v2.5.0 (94% faster keyword matching, 28% faster file resolution) were so effective that we ran into an unexpected problem: **RobotCode** now finishes analysis before some editors are ready to receive the results.
+
+To address this, we've added **Proactive Performance Mode**. When enabled, **RobotCode** uses the leftover time between analysis completion and editor readiness to perform speculative work:
+
+- pre-resolving keywords from libraries you haven't imported yet but statistically might
+- warming up code completion for keyword arguments you're likely to type based on cursor position history
+- pre-computing diagnostics for code you haven't written yet, based on how similar keyword calls usually end
+
+This occasionally leads to diagnostic warnings appearing for lines that don't exist yet. This is expected behavior and usually means you were going to make that mistake anyway.
+
+## Emotional Code Completion
+
+The new type hint-based completion for `Literal` values turned out to be just the beginning. Our analysis of completion acceptance rates revealed that keyword suggestions are significantly more effective when they match the developer's current *emotional context*.
+
+**RobotCode** now analyzes several signals to determine your coding mood:
+
+- typing speed and error correction frequency
+- time since last successful test run
+- number of times you've hovered over the same unresolved keyword
+- current scroll velocity (fast scrolling = frustration, slow scrolling = contemplation)
+
+Based on this, code completion now adjusts its suggestions:
+
+- **Confident mode**: shows advanced keywords, complex argument patterns, embedded arguments
+- **Cautious mode**: prioritizes well-tested keywords with high call frequency in your workspace
+- **Frustrated mode**: moves `Sleep` and `Log To Console` to the top of every completion list
+- **Resignation mode**: suggests `[Tags]    known-issue` and `Skip    Not today`
+
+## Keyword Adoption Program
+
+Finding unused keywords with `robotcode analyze code --collect-unused` was a much-requested feature. But simply *listing* unused keywords felt incomplete. These keywords were written by someone, probably with good intentions, possibly on a Friday afternoon. They deserve better than a cold diagnostic message.
+
+**RobotCode** now offers the **Keyword Adoption Program**. When an unused keyword is detected, instead of just flagging it, **RobotCode**:
+
+- checks if any other workspace in your organization could use it (via the new optional Keyword Sharing Protocol)
+- generates a short "keyword biography" describing when it was written, how many times it was called in happier times, and what it probably hoped to achieve
+- suggests test cases where it *could* be useful, even if nobody asked
+
+Keywords that remain unadopted for more than 30 days receive a farewell message in the Problems panel before being eligible for cleanup.
+
+You can sponsor a keyword to prevent its removal:
+
+```toml
+[tool.robotcode-analyze.code]
+sponsored-keywords = ["Click All The Things", "Verify Everything Is Fine"]
+```
+
+## Cache Mood Indicators
+
+The new `robotcode analyze cache` CLI commands give you full control over your analysis cache. But raw statistics felt impersonal, so we've added a **Cache Mood** indicator.
+
+Your cache now has feelings:
+
+```bash
+$ robotcode analyze cache info
+Cache status: 😊 Content (2,847 entries, 98.2% hit rate)
+```
+
+Possible moods:
+
+- 😊 **Content** — high hit rate, low invalidation, everything is in harmony
+- 😐 **Indifferent** — moderate hit rate, cache is doing its job but doesn't feel appreciated
+- 😟 **Anxious** — frequent invalidations, the cache is worried it might not be needed anymore
+- 😤 **Frustrated** — constant cache misses, usually caused by rapidly changing files, the cache would like you to please make up your mind
+- 💔 **Heartbroken** — you ran `cache prune`, the cache remembers everything that was lost
+
+Running `cache prune` followed by `cache info` now shows a brief memorial of what was deleted, including the oldest entry's creation date and a message like "It had been with you since Tuesday."
+
+## ProjectIndex: The Keyword Social Network
+
+The new workspace-wide `ProjectIndex` tracks references between keywords, variables, and namespaces. Internally, this is a straightforward inverse index. But we realized the data maps surprisingly well to social network concepts.
+
+The new **Keyword Social Graph** (available via `robotcode analyze social`) shows:
+
+- **Popularity**: which keywords are called by the most test cases
+- **Influence**: keywords whose failure would cascade to the most other tests
+- **Cliques**: groups of keywords that are always used together and never separately
+- **Loners**: keywords with zero incoming references (see: Keyword Adoption Program above)
+- **Frenemies**: keyword pairs that are frequently used in the same test but never in the same keyword call — suggesting an unresolved tension
+
+Keywords with high influence automatically receive a **[Critical]** badge in code completion. Keywords in the "Loners" category get a 💬 icon suggesting they "reach out" to nearby test cases.
+
+## Known Limitations
+
+- Predictive caching defaults to `"clairvoyant"` on Fridays, which can cause unexpected cache entries for files in branches you haven't checked out yet
+- Emotional code completion cannot detect sarcasm in keyword names
+- The Keyword Adoption Program does not yet support cross-company adoption due to GDPR concerns
+- Cache mood indicators are not yet configurable and may not reflect your own feelings about the cache
+- `robotcode analyze social --include-drama` is available but not recommended in production environments
+- The keyword social graph may reveal uncomfortable truths about your project's architecture
+
+## Breaking Changes
+
+- Cache entries now have feelings and may resist deletion if recently populated
+- Keyword completion order may vary depending on your emotional state
+- Running `cache prune` now prompts "Are you sure?" followed by "Are you really sure?" followed by a 5-second countdown
+
+## Migration Guide
+
+No manual migration is required. However, we recommend:
+
+- giving your team a heads-up about the keyword biographies before someone gets emotional
+- reviewing your CI pipeline expectations around cache mood
+- not running `robotcode analyze social --include-drama` during sprint reviews
+- checking the date before filing issues about any of the above
+
+---
+
+## What Actually Changed
+
+Happy April 1st! 😄
+
+None of the above features exist. Probably for the best. But there *is* a real v2.5.0 release — and it's actually worth reading.
+
+👉 **[Read the real release notes here](./2026-03-31-whats-new-v2.5.0)** 👈

docs/news/posts.data.ts

@@ -4,6 +4,7 @@ export default createContentLoader("news/*.md", {
   transform(raw) {
     return raw
       .filter((p) => p.url !== "/news/")
+      .filter((p) => !p.frontmatter.aprilFools || new Date() <= new Date("2026-04-02T12:00:00"))
       .sort((a, b) => {
         return +new Date(b.frontmatter.date) - +new Date(a.frontmatter.date);
       });