Implement Deep Codebase Context Grounding for Enhanced Session Awareness

[inspiration88]

Problem Statement / Motivation:
Currently, Roo's ability to understand the broader context of a codebase feels limited, especially in large or complex projects. When a user asks for assistance, the responses often lack a deep awareness of the project's architecture, conventions, and inter-dependencies.
This can be contrasted with tools like Gemini-CLI, where a command like @src can perform a deep, upfront analysis of a directory, resulting in highly context-aware and accurate suggestions. In comparison, Roo's current context-gathering feels significantly less comprehensive, capturing perhaps only a fraction of the necessary project knowledge.
This gap forces the user to spend considerable time providing manual context, correcting suggestions, and re-explaining project-specific nuances, which disrupts the development flow.

Proposed Solution:
I propose the implementation of a "Deep Context Grounding" mechanism in Roo. This feature would work in two stages:
Initial Grounding/Indexing: Introduce a mechanism for Roo to perform an intensive, in-depth analysis of a specified scope (e.g., the entire workspace, a @src directory). This could be an explicit command like @workspace:index or an automatic process at the start of a session. This process would build a detailed internal model of the codebase, including:
Symbol definitions and locations (functions, classes, types, etc.).
File dependencies and module relationships.
Commonly used patterns, libraries, and architectural conventions.
Type definitions and interfaces.
Persistent Session Context: This indexed "grounding" should be persisted and actively referenced for the entire duration of the coding session. Every subsequent prompt or task would leverage this pre-established, rich context, eliminating the need for repeated, shallow analysis.
The goal is to mimic the high level of project awareness seen in tools like Google's Project IDX or Firebase Studio, where the AI feels pre-loaded with a comprehensive understanding of the project.

Benefits / Impact:
Exponentially Better Outcomes: By understanding the project deeply, Roo's suggestions will move from generic to idiomatic, fitting seamlessly into the existing codebase.
Increased Efficiency: Drastically reduces the time developers spend "onboarding" the AI to their project in every single prompt.
Superior User Experience: This creates a powerful feeling of working with a true collaborator who "knows the product." For developers who value deep focus, this enables a state of flow, making the interaction feel more like a partnership and less like a Q&A session.

Extending Roo with this capability would be a massive leap forward, empowering developers to work faster and more intuitively. Thank you for considering this enhancement.

[inspiration88]

Further Refinements & The "Why": Stateful Context to Prevent AI-Introduced Fragmentation

Hi team,

Following up on my original feature request, I want to add some crucial refinements that connect the technical solution with the deep, practical "why" behind this need.

The Core Problem: AI-Introduced Codebase Fragmentation

For developers like me who rely heavily on AI as a "vibe coder" and coding partner, there's a devastating side effect to the AI's current lack of deep context: it actively introduces architectural inconsistency and technical debt.

Here's the painful, real-world scenario:

1. I start a project using the latest libraries and best practices.
2. In one area, I might use an external tool or my own knowledge to correctly implement a modern pattern.
3. I then ask Roo for help in a different part of the codebase.
4. Unaware of the project's specific dependencies or my recent changes, Roo injects code based on its older, generalized training data.

The result is a fragmented codebase—a messy mix of modern and outdated practices. This forces me to switch from a "creator" mindset to that of a "code janitor," constantly auditing the AI's output to prevent it from degrading the project's integrity. It breaks the flow and erodes the trust required for a true AI partnership.

The Solution: A Practical Path to a Consistent, Project-Aware AI

To solve this, the deep context grounding needs two key technical pillars that make it both powerful and practical:

1. Library Version Awareness:
The AI must stop relying on its outdated general knowledge. As part of the initial grounding scan, Roo should:

• Parse dependency manifests (e.g., package.json, pyproject.toml, go.mod).
• Use this to fetch context (APIs, type definitions, best practices) for the exact versions of the libraries being used in this specific project.
• This alone would eliminate a huge class of errors and stop the injection of deprecated code.

2. Stateful, Evolving, and Cached Context:
A full re-scan with every prompt is infeasible. The context must be smart and efficient.

• Create an Initial "Memory Buffer": The initial scan should generate a high-level, abstract model of the project's architecture—a map of "how things work," including the library versions.
• Make it Stateful & Evolving: This "memory buffer" must be saved for the session and intelligently updated in near real-time as I save files or make changes. The AI's knowledge grows with the project.
• Cache for Efficiency: This high-level architectural map must be cached. Subsequent prompts would then only need to send the new query and a small "delta" of relevant code, which is applied against the rich, persistent context. This avoids the massive performance and cost issues of sending 300k+ tokens on every request.

By combining these refinements, Roo moves beyond being a simple code generator. It becomes a guardian of architectural consistency. It stops being a potential source of technical debt and transforms into a partner you can trust to uphold and enhance the integrity of your entire codebase.

[inspiration88]

Updated and empowered in #5191