code-graph-rag 0.2.0__tar.gz → 0.2.16__tar.gz

{code_graph_rag-0.2.0/code_graph_rag.egg-info → code_graph_rag-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.2.0
+Version: 0.2.16
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo
@@ -19,7 +19,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp<2,>=1.28.1
+Requires-Dist: mcp<2,>=1.30.0
 Requires-Dist: pydantic-ai-slim[anthropic,google,openai]>=2.0.0
 Requires-Dist: pydantic-settings>=2.12.0
 Requires-Dist: python-dotenv>=1.2.1
@@ -93,7 +93,7 @@ Dynamic: license-file
 
 # Code-Graph-RAG
 
-Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in an embedded graph database that needs no server, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
 
 ## What It Does
 
@@ -152,8 +152,9 @@ transformers are then not required locally.
 `pip install code-graph-rag` gives you the newest PyPI release, which is deliberately
 not the newest commit. Git tags exist for every version (one per merge), while PyPI
 uploads and GitHub Release binaries land on an every-50 cadence, so the tag on `main`
-usually runs ahead of the published version. A security fix is the exception: it
-ships immediately rather than waiting for the cadence.
+usually runs ahead of the published version. A security fix, a breaking change or a
+merge a maintainer labels `release now` is the exception: each ships immediately
+rather than waiting for the cadence.
 
 To run code newer than the latest release, install from git with uv:
 
@@ -175,14 +176,22 @@ for git installs and the other methods.
 ### Prerequisites
 
 - Python 3.12+
-- Docker (for Memgraph)
-- `cmake` (for building pymgclient)
 - `ripgrep` (`rg`) (for shell command text searching)
+- Only for the optional Memgraph backend: Docker, and `cmake` where no
+  `pymgclient` wheel fits your platform
+
+The knowledge graph is an embedded SQLite file (`~/.cgr/graph.sqlite`), so there
+is no database server to run. Memgraph and Neo4j remain available as opt-in
+backends; see [Graph Backends](https://docs.code-graph-rag.com/architecture/embedded-graph/).
 
 The wheel is pure Python (`py3-none-any`), so it installs on any platform with
-Python 3.12 or newer. Some distributions ship an older interpreter (Debian
-Bookworm, and so Raspberry Pi OS Bookworm, ships 3.11), which also explains the
-failed piwheels Bookworm build. On those systems, see the [installation
+Python 3.12 or newer. On Linux (x86_64, aarch64), macOS and Windows x64 it also
+pulls in `cgr-graph-rs`, a native extension that speeds up the embedded graph;
+elsewhere the same engine runs in pure Python.
+
+Some distributions ship an older interpreter (Debian Bookworm, and so Raspberry
+Pi OS Bookworm, ships 3.11), which also explains the failed piwheels Bookworm
+build. On those systems, see the [installation
 guide](https://github.com/vitali87/code-graph-rag/blob/main/docs/getting-started/installation.md#older-system-interpreters)
 for the available interpreter-pinning alternatives.
 
@@ -190,14 +199,17 @@ for the available interpreter-pinning alternatives.
 
 The package installs a `cgr` command.
 
-**Start Memgraph, parse a repo, and query it:**
+**Parse a repo, then query it:**
 
 ```bash
-cgr daemon up                              # start Memgraph + Qdrant
-cgr start --repo-path ./my-project \
-          --update-graph --clean           # parse & launch interactive chat
+cgr start --repo-path ./my-project --update-graph   # parse into the graph
+cgr start --repo-path ./my-project                  # launch the interactive chat
 ```
 
+The graph is written to `~/.cgr/graph.sqlite`. To use Memgraph instead, install
+`code-graph-rag[memgraph]`, set `GRAPH_BACKEND=memgraph`, and start the packaged
+Memgraph + Qdrant stack with `cgr daemon up`.
+
 **Index to protobuf for offline use:**
 
 ```bash
@@ -304,7 +316,11 @@ for fn in functions[:5]:
     print(f"{fn.properties['name']}: {len(rels)} relationships")
 ```
 
-### Query Memgraph with Cypher
+### Query the graph with Cypher
+
+`MemgraphIngestor` keeps its original name but works with whichever backend
+`GRAPH_BACKEND` selects. On the default embedded graph, `host` and `port` are
+not used.
 
 ```python
 from cgr import MemgraphIngestor
@@ -357,8 +373,10 @@ Configure via `.env` or environment variables:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname |
-| `MEMGRAPH_PORT` | `7687` | Memgraph port |
+| `GRAPH_BACKEND` | `sqlite` | Graph engine: `sqlite` (embedded), `memgraph`, or `neo4j` |
+| `SQLITE_GRAPH_PATH` | `~/.cgr/graph.sqlite` | Embedded graph file |
+| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname (with `GRAPH_BACKEND=memgraph`) |
+| `MEMGRAPH_PORT` | `7687` | Memgraph port (with `GRAPH_BACKEND=memgraph`) |
 | `ORCHESTRATOR_PROVIDER` | | Provider: `google`, `openai`, `anthropic`, `azure`, `ollama`, `minimax`, `litellm_proxy` |
 | `ORCHESTRATOR_MODEL` | | Model ID (e.g. `gpt-5.6-terra`, `gemini-3.6-flash`, `claude-sonnet-5`, `qwen2.5-coder`) |
 | `ORCHESTRATOR_API_KEY` | | API key for the provider (not needed for `ollama`) |

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/PYPI_README.md

@@ -1,6 +1,6 @@
 # Code-Graph-RAG
 
-Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in an embedded graph database that needs no server, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
 
 ## What It Does
 
@@ -59,8 +59,9 @@ transformers are then not required locally.
 `pip install code-graph-rag` gives you the newest PyPI release, which is deliberately
 not the newest commit. Git tags exist for every version (one per merge), while PyPI
 uploads and GitHub Release binaries land on an every-50 cadence, so the tag on `main`
-usually runs ahead of the published version. A security fix is the exception: it
-ships immediately rather than waiting for the cadence.
+usually runs ahead of the published version. A security fix, a breaking change or a
+merge a maintainer labels `release now` is the exception: each ships immediately
+rather than waiting for the cadence.
 
 To run code newer than the latest release, install from git with uv:
 
@@ -82,14 +83,22 @@ for git installs and the other methods.
 ### Prerequisites
 
 - Python 3.12+
-- Docker (for Memgraph)
-- `cmake` (for building pymgclient)
 - `ripgrep` (`rg`) (for shell command text searching)
+- Only for the optional Memgraph backend: Docker, and `cmake` where no
+  `pymgclient` wheel fits your platform
+
+The knowledge graph is an embedded SQLite file (`~/.cgr/graph.sqlite`), so there
+is no database server to run. Memgraph and Neo4j remain available as opt-in
+backends; see [Graph Backends](https://docs.code-graph-rag.com/architecture/embedded-graph/).
 
 The wheel is pure Python (`py3-none-any`), so it installs on any platform with
-Python 3.12 or newer. Some distributions ship an older interpreter (Debian
-Bookworm, and so Raspberry Pi OS Bookworm, ships 3.11), which also explains the
-failed piwheels Bookworm build. On those systems, see the [installation
+Python 3.12 or newer. On Linux (x86_64, aarch64), macOS and Windows x64 it also
+pulls in `cgr-graph-rs`, a native extension that speeds up the embedded graph;
+elsewhere the same engine runs in pure Python.
+
+Some distributions ship an older interpreter (Debian Bookworm, and so Raspberry
+Pi OS Bookworm, ships 3.11), which also explains the failed piwheels Bookworm
+build. On those systems, see the [installation
 guide](https://github.com/vitali87/code-graph-rag/blob/main/docs/getting-started/installation.md#older-system-interpreters)
 for the available interpreter-pinning alternatives.
 
@@ -97,14 +106,17 @@ for the available interpreter-pinning alternatives.
 
 The package installs a `cgr` command.
 
-**Start Memgraph, parse a repo, and query it:**
+**Parse a repo, then query it:**
 
 ```bash
-cgr daemon up                              # start Memgraph + Qdrant
-cgr start --repo-path ./my-project \
-          --update-graph --clean           # parse & launch interactive chat
+cgr start --repo-path ./my-project --update-graph   # parse into the graph
+cgr start --repo-path ./my-project                  # launch the interactive chat
 ```
 
+The graph is written to `~/.cgr/graph.sqlite`. To use Memgraph instead, install
+`code-graph-rag[memgraph]`, set `GRAPH_BACKEND=memgraph`, and start the packaged
+Memgraph + Qdrant stack with `cgr daemon up`.
+
 **Index to protobuf for offline use:**
 
 ```bash
@@ -211,7 +223,11 @@ for fn in functions[:5]:
     print(f"{fn.properties['name']}: {len(rels)} relationships")
 ```
 
-### Query Memgraph with Cypher
+### Query the graph with Cypher
+
+`MemgraphIngestor` keeps its original name but works with whichever backend
+`GRAPH_BACKEND` selects. On the default embedded graph, `host` and `port` are
+not used.
 
 ```python
 from cgr import MemgraphIngestor
@@ -264,8 +280,10 @@ Configure via `.env` or environment variables:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname |
-| `MEMGRAPH_PORT` | `7687` | Memgraph port |
+| `GRAPH_BACKEND` | `sqlite` | Graph engine: `sqlite` (embedded), `memgraph`, or `neo4j` |
+| `SQLITE_GRAPH_PATH` | `~/.cgr/graph.sqlite` | Embedded graph file |
+| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname (with `GRAPH_BACKEND=memgraph`) |
+| `MEMGRAPH_PORT` | `7687` | Memgraph port (with `GRAPH_BACKEND=memgraph`) |
 | `ORCHESTRATOR_PROVIDER` | | Provider: `google`, `openai`, `anthropic`, `azure`, `ollama`, `minimax`, `litellm_proxy` |
 | `ORCHESTRATOR_MODEL` | | Model ID (e.g. `gpt-5.6-terra`, `gemini-3.6-flash`, `claude-sonnet-5`, `qwen2.5-coder`) |
 | `ORCHESTRATOR_API_KEY` | | API key for the provider (not needed for `ollama`) |

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/README.md

@@ -42,13 +42,13 @@
 
 # Code-Graph-RAG
 
-Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in an embedded graph database that needs no server, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
 
 <p align="center">
   <b>1. Index:</b> <code>cgr start --update-graph</code> parses a repository into a knowledge graph (sped up)
 </p>
 <p align="center">
-  <img src="./assets/demo-indexing.gif" alt="cgr parsing the code-graph-rag repository into a Memgraph knowledge graph, then printing node and relationship counts">
+  <img src="./assets/demo-indexing.gif" alt="cgr parsing the code-graph-rag repository into a knowledge graph, then printing node and relationship counts">
 </p>
 
 <p align="center">
@@ -61,8 +61,8 @@ Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by c
 ## Latest News 🔥
 
 <!-- SECTION:latest_news -->
-- **Contextual Queries**: Support for more detailed context queries has been added, including reasons and evaluation ingestor reads, enhancing the understanding of code interactions.
-- **Graph Improvements**: The graph analysis capabilities have been expanded to follow cross-service links and implementors/overrides, providing a more comprehensive view of code dependencies.
+- **Python**: Added support for inferring instance attributes from annotations.
+- **General**: Various fixes for import resolution, naming conflicts, and project syncing.
 <!-- /SECTION:latest_news -->
 
 See [NEWS.md](NEWS.md) for the full history.
@@ -83,15 +83,17 @@ Point Code-Graph-RAG at a repository and it reads every source file, extracts fu
 
 The system has two components:
 
-1. **Multi-language parser.** A Tree-sitter based parser reads the codebase and ingests functions, classes, methods, modules, and their relationships into Memgraph under a single language-agnostic schema. Where a toolchain is available, compiler-grade frontends layer exact facts on top (libclang for C/C++, `go/types` for Go, and opt-in Roslyn, `javac` and Jedi for C#, Java and Python), and [dynamic tracing](docs/guide/dynamic-tracing.md) merges calls observed at runtime. Tree-sitter stays the backbone: a trace only sees code that ran, and a compiler frontend only covers what its toolchain can build.
+1. **Multi-language parser.** A Tree-sitter based parser reads the codebase and ingests functions, classes, methods, modules, and their relationships into the graph under a single language-agnostic schema. Where a toolchain is available, compiler-grade frontends layer exact facts on top (libclang for C/C++, `go/types` for Go, and opt-in Roslyn, `javac` and Jedi for C#, Java and Python), and [dynamic tracing](docs/guide/dynamic-tracing.md) merges calls observed at runtime. Tree-sitter stays the backbone: a trace only sees code that ran, and a compiler frontend only covers what its toolchain can build.
 2. **RAG system** (`codebase_rag/`). An interactive CLI that turns natural language into Cypher queries, retrieves matching code, and drives AI-powered editing and optimisation.
 
 ```
-Source Code -> Tree-sitter Parser -> AST Analysis -> Memgraph Knowledge Graph
+Source Code -> Tree-sitter Parser -> AST Analysis -> Knowledge Graph
                                                              |
 User Query -> AI Model (Cypher Gen) -> Cypher Query -> Graph Results -> Response
 ```
 
+The graph is stored in an embedded SQLite file by default. Memgraph and Neo4j are opt-in backends that run the same Cypher; [Graph Backends](docs/architecture/embedded-graph.md) compares them.
+
 See the [Architecture Overview](docs/architecture/overview.md) and [Graph Schema](docs/architecture/graph-schema.md) for the full picture.
 
 ## Supported Languages
@@ -117,13 +119,14 @@ Three version lines exist and they intentionally differ:
 | where | what it tracks |
 |---|---|
 | git tags | every version, one per merge |
-| GitHub Releases (binaries, signatures) | every 50th version, plus any security fix |
-| PyPI | every 50th version, plus any security fix |
+| GitHub Releases (binaries, signatures) | every 50th version, plus any security fix, breaking change or merge labelled `release now` |
+| PyPI | every 50th version, plus any security fix, breaking change or merge labelled `release now` |
 
 So the newest tag on `main` usually runs ahead of the newest release, often by
 tens of patch versions; they coincide only just after a release. Nothing is
-stuck, the cadences differ by design. A security fix does NOT wait for the
-cadence: it ships a release and a PyPI upload immediately.
+stuck, the cadences differ by design. A security fix, a breaking change or a
+merge a maintainer labels `release now` does NOT wait for the cadence: each ships
+a release and a PyPI upload immediately.
 
 `uv tool install` and `pipx install` give you the newest PyPI version, which is the
 newest RELEASE, not the newest tag. Interim tags exist so every merge is
@@ -190,6 +193,7 @@ Code-Graph-RAG runs as an [MCP](https://modelcontextprotocol.io) server so Claud
 **Architecture**
 - [Overview](docs/architecture/overview.md)
 - [Graph Schema](docs/architecture/graph-schema.md)
+- [Graph Backends](docs/architecture/embedded-graph.md)
 - [Language Support](docs/architecture/language-support.md)
 - [Data-Flow Edges](docs/architecture/data-flow-edges.md)
 
@@ -224,6 +228,8 @@ Please see [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines. Good
 
 For issues or questions, check the [Troubleshooting](docs/advanced/troubleshooting.md) guide first, then open an issue.
 
+If cgr is useful to you, please consider pledging support on [GitHub Sponsors](https://github.com/sponsors/vitali87). cgr links the page under `cgr --version` and, in a terminal, after most commands finish; set `CGR_SPONSOR_PLEDGE=false` to hide that line.
+
 ## License
 
 MIT. See [LICENSE](LICENSE).

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16/code_graph_rag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.2.0
+Version: 0.2.16
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo
@@ -19,7 +19,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp<2,>=1.28.1
+Requires-Dist: mcp<2,>=1.30.0
 Requires-Dist: pydantic-ai-slim[anthropic,google,openai]>=2.0.0
 Requires-Dist: pydantic-settings>=2.12.0
 Requires-Dist: python-dotenv>=1.2.1
@@ -93,7 +93,7 @@ Dynamic: license-file
 
 # Code-Graph-RAG
 
-Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by compiler-grade frontends and runtime traces where available, builds a knowledge graph of its structure in an embedded graph database that needs no server, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
 
 ## What It Does
 
@@ -152,8 +152,9 @@ transformers are then not required locally.
 `pip install code-graph-rag` gives you the newest PyPI release, which is deliberately
 not the newest commit. Git tags exist for every version (one per merge), while PyPI
 uploads and GitHub Release binaries land on an every-50 cadence, so the tag on `main`
-usually runs ahead of the published version. A security fix is the exception: it
-ships immediately rather than waiting for the cadence.
+usually runs ahead of the published version. A security fix, a breaking change or a
+merge a maintainer labels `release now` is the exception: each ships immediately
+rather than waiting for the cadence.
 
 To run code newer than the latest release, install from git with uv:
 
@@ -175,14 +176,22 @@ for git installs and the other methods.
 ### Prerequisites
 
 - Python 3.12+
-- Docker (for Memgraph)
-- `cmake` (for building pymgclient)
 - `ripgrep` (`rg`) (for shell command text searching)
+- Only for the optional Memgraph backend: Docker, and `cmake` where no
+  `pymgclient` wheel fits your platform
+
+The knowledge graph is an embedded SQLite file (`~/.cgr/graph.sqlite`), so there
+is no database server to run. Memgraph and Neo4j remain available as opt-in
+backends; see [Graph Backends](https://docs.code-graph-rag.com/architecture/embedded-graph/).
 
 The wheel is pure Python (`py3-none-any`), so it installs on any platform with
-Python 3.12 or newer. Some distributions ship an older interpreter (Debian
-Bookworm, and so Raspberry Pi OS Bookworm, ships 3.11), which also explains the
-failed piwheels Bookworm build. On those systems, see the [installation
+Python 3.12 or newer. On Linux (x86_64, aarch64), macOS and Windows x64 it also
+pulls in `cgr-graph-rs`, a native extension that speeds up the embedded graph;
+elsewhere the same engine runs in pure Python.
+
+Some distributions ship an older interpreter (Debian Bookworm, and so Raspberry
+Pi OS Bookworm, ships 3.11), which also explains the failed piwheels Bookworm
+build. On those systems, see the [installation
 guide](https://github.com/vitali87/code-graph-rag/blob/main/docs/getting-started/installation.md#older-system-interpreters)
 for the available interpreter-pinning alternatives.
 
@@ -190,14 +199,17 @@ for the available interpreter-pinning alternatives.
 
 The package installs a `cgr` command.
 
-**Start Memgraph, parse a repo, and query it:**
+**Parse a repo, then query it:**
 
 ```bash
-cgr daemon up                              # start Memgraph + Qdrant
-cgr start --repo-path ./my-project \
-          --update-graph --clean           # parse & launch interactive chat
+cgr start --repo-path ./my-project --update-graph   # parse into the graph
+cgr start --repo-path ./my-project                  # launch the interactive chat
 ```
 
+The graph is written to `~/.cgr/graph.sqlite`. To use Memgraph instead, install
+`code-graph-rag[memgraph]`, set `GRAPH_BACKEND=memgraph`, and start the packaged
+Memgraph + Qdrant stack with `cgr daemon up`.
+
 **Index to protobuf for offline use:**
 
 ```bash
@@ -304,7 +316,11 @@ for fn in functions[:5]:
     print(f"{fn.properties['name']}: {len(rels)} relationships")
 ```
 
-### Query Memgraph with Cypher
+### Query the graph with Cypher
+
+`MemgraphIngestor` keeps its original name but works with whichever backend
+`GRAPH_BACKEND` selects. On the default embedded graph, `host` and `port` are
+not used.
 
 ```python
 from cgr import MemgraphIngestor
@@ -357,8 +373,10 @@ Configure via `.env` or environment variables:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname |
-| `MEMGRAPH_PORT` | `7687` | Memgraph port |
+| `GRAPH_BACKEND` | `sqlite` | Graph engine: `sqlite` (embedded), `memgraph`, or `neo4j` |
+| `SQLITE_GRAPH_PATH` | `~/.cgr/graph.sqlite` | Embedded graph file |
+| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname (with `GRAPH_BACKEND=memgraph`) |
+| `MEMGRAPH_PORT` | `7687` | Memgraph port (with `GRAPH_BACKEND=memgraph`) |
 | `ORCHESTRATOR_PROVIDER` | | Provider: `google`, `openai`, `anthropic`, `azure`, `ollama`, `minimax`, `litellm_proxy` |
 | `ORCHESTRATOR_MODEL` | | Model ID (e.g. `gpt-5.6-terra`, `gemini-3.6-flash`, `claude-sonnet-5`, `qwen2.5-coder`) |
 | `ORCHESTRATOR_API_KEY` | | API key for the provider (not needed for `ollama`) |

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/code_graph_rag.egg-info/SOURCES.txt

@@ -162,6 +162,7 @@ codebase_rag/editing/imports.py
 codebase_rag/editing/occurrences.py
 codebase_rag/editing/patcher.py
 codebase_rag/editing/rename.py
+codebase_rag/editing/signature_bind.py
 codebase_rag/editing/signature_contract.py
 codebase_rag/editing/signature_spec.py
 codebase_rag/editing/sites.py
@@ -269,6 +270,7 @@ codebase_rag/parsers/csharp_frontend/roslyn/Frontend.cs
 codebase_rag/parsers/csharp_frontend/roslyn/Frontend.csproj
 codebase_rag/parsers/csharp_frontend/roslyn/Program.cs
 codebase_rag/parsers/dart/__init__.py
+codebase_rag/parsers/dart/package_paths.py
 codebase_rag/parsers/dart/type_inference.py
 codebase_rag/parsers/dart/utils.py
 codebase_rag/parsers/flow_access/__init__.py
@@ -314,6 +316,7 @@ codebase_rag/parsers/io_access/extract.py
 codebase_rag/parsers/io_access/models.py
 codebase_rag/parsers/io_access/processor.py
 codebase_rag/parsers/io_access/registry.py
+codebase_rag/parsers/io_access/resource_names.py
 codebase_rag/parsers/io_access/url_folding.py
 codebase_rag/parsers/java/__init__.py
 codebase_rag/parsers/java/method_resolver.py

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/code_graph_rag.egg-info/requires.txt

@@ -1,5 +1,5 @@
 loguru>=0.7.3
-mcp<2,>=1.28.1
+mcp<2,>=1.30.0
 pydantic-ai-slim[anthropic,google,openai]>=2.0.0
 pydantic-settings>=2.12.0
 python-dotenv>=1.2.1

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/codebase_rag/cli.py

@@ -44,7 +44,7 @@ from .capture import (
     unknown_tokens,
 )
 from .checkout_state import prepare_state_dir
-from .cli_runtime import app_context, connect_memgraph, style
+from .cli_runtime import app_context, connect_memgraph, dim, style
 from .config import load_ignore_patterns, settings, settings_errors
 from .console_marks import status_mark
 from .editing.cli import cli as edits_cli
@@ -60,6 +60,7 @@ from .graph_cli import cli as graph_cli
 from .graph_dialects import DIALECT_MEMGRAPH
 from .parser_loader import load_parsers
 from .project_selection import ProjectChoice, choose_project, scope_refusal
+from .services.gloss_cleanup import prune_orphaned_glosses
 from .services.graph_diff import DiffError, diff_indexes, diff_is_empty
 from .services.graph_service import GraphUnavailableError, MemgraphIngestor
 from .services.protobuf_service import ProtobufFileIngestor
@@ -102,6 +103,7 @@ from .utils.path_utils import (
     normalize_project_name,
     project_name_error,
     project_roots_from_rows,
+    projects_sharing_root,
     resolve_repo_path,
     unwritable_output_reason,
 )
@@ -199,10 +201,40 @@ class _CgrGroup(TyperGroup):
         # this at connect time with the fix in its message; printing it here
         # covers them all, the delegated groups and the chat included (#2443).
         try:
-            return super().invoke(ctx)
+            result = super().invoke(ctx)
         except GraphUnavailableError as e:
             app_context.console.print(style(str(e), cs.Color.RED))
             raise typer.Exit(1) from e
+        # Only a command that finished gets here: a failure exits by raising.
+        pledge = sponsor_pledge(ctx.invoked_subcommand, sys.stderr.isatty())
+        if pledge:
+            # Soft-wrapped so the terminal, not Rich, breaks the line, and
+            # the URL stays one clickable link.
+            terminal_aware_console(stderr=True).print(
+                dim(pledge), highlight=False, soft_wrap=True
+            )
+        return result
+
+
+# Help pages, and the MCP server, which speaks its protocol until the client
+# hangs up, are not runs that finished.
+_NO_SPONSOR_PLEDGE = frozenset({ch.CLICommandName.HELP, ch.CLICommandName.MCP_SERVER})
+
+
+def sponsor_pledge(command: str | None, terminal: bool) -> str | None:
+    """The GitHub Sponsors line a finished command ends on, or None where it
+    would be in the way: off a terminal (a script or a log reading stderr),
+    under `--quiet` or CGR_SPONSOR_PLEDGE=false, and after the commands in
+    `_NO_SPONSOR_PLEDGE`. On stderr, so it never mixes into a command's
+    output on stdout."""
+    if (
+        not terminal
+        or settings.QUIET
+        or not settings.SPONSOR_PLEDGE
+        or command in _NO_SPONSOR_PLEDGE
+    ):
+        return None
+    return cs.CLI_MSG_SPONSOR_PLEDGE.format(url=cs.SPONSOR_URL)
 
 
 app = typer.Typer(
@@ -225,6 +257,9 @@ def _version_callback(value: bool) -> None:
         )
         for line in credits_lines():
             app_context.console.print(line, highlight=False)
+        app_context.console.print(
+            cs.CLI_MSG_SPONSOR.format(url=cs.SPONSOR_URL), highlight=False
+        )
         raise typer.Exit()
 
 
@@ -1035,6 +1070,28 @@ def _clear_deleted_project_markers(
         logger.warning(ls.CLI_DELETE_SYNC_MARKER_KEPT.format(project=project_name))
 
 
+def _sweep_glosses_after_failed_delete(
+    ingestor: MemgraphIngestor, project_name: str
+) -> None:
+    """Sweep the notes of a delete that raised after the project was removed.
+
+    The delete commits statement by statement, so a later cleanup can raise
+    once the project is already gone, and a retry then stops at "project not
+    found" before any sweep. A project still listed keeps its unattached
+    notes: they are LOST or AMBIGUOUS by design and readable on their old
+    names. Never raises, so the delete's own error is what is reported.
+    """
+    try:
+        still_listed = project_name in ingestor.list_projects()
+    except Exception as exc:
+        logger.warning(
+            ls.CLI_DELETE_GLOSS_SWEEP_SKIPPED.format(project=project_name, error=exc)
+        )
+        return
+    if not still_listed:
+        prune_orphaned_glosses(ingestor, project_name)
+
+
 def _run_updater_deferring_interrupt(
     updater: "GraphUpdater",
 ) -> KeyboardInterrupt | None:
@@ -1173,10 +1230,33 @@ def _run_graph_sync(
                 cs.StyleModifier.NONE,
             )
         )
+        _report_call_pass_failures(repo, list(updater.call_pass_failures))
     if interrupted is not None:
         raise interrupted
 
 
+def _report_call_pass_failures(repo: Path, failed: list[Path]) -> None:
+    # A file whose call pass failed lost edges while the sync still reads
+    # "done": the error lines scroll away, so the summary counts them (#3173).
+    if not failed:
+        return
+    names = sorted(
+        path.relative_to(repo).as_posix() if path.is_relative_to(repo) else str(path)
+        for path in failed
+    )
+    shown = names[: cs.CLI_CALL_PASS_FAILURES_SHOWN]
+    if len(names) > len(shown):
+        shown.append(cs.CLI_MSG_AND_MORE.format(count=len(names) - len(shown)))
+    app_context.console.print(
+        style(
+            cs.CLI_MSG_CALL_PASS_FAILURES.format(
+                count=len(names), files=", ".join(shown)
+            ),
+            cs.Color.YELLOW,
+        )
+    )
+
+
 def _delete_hash_cache(repo_path: Path) -> None:
     # Resolving the state directory also moves in what an older cgr left in
     # the tree, so a clean right after upgrading clears that copy too.
@@ -3463,6 +3543,21 @@ def delete_project(
                 app_context.console.print(style(choice.refusal, cs.Color.RED))
                 raise typer.Exit(1)
 
+            # A directory indexed under two names used to lose both on delete
+            # (#2665). The delete is ownership-scoped now; say so before it runs.
+            roots = ingestor.list_project_roots()
+            if sharing := projects_sharing_root(project_name, roots):
+                app_context.console.print(
+                    style(
+                        cs.CLI_WARN_DELETE_PROJECT_SHARED_ROOT.format(
+                            projects=", ".join(sharing),
+                            project_name=project_name,
+                            root_path=roots[project_name],
+                        ),
+                        cs.Color.YELLOW,
+                    )
+                )
+
             _info(
                 style(
                     cs.CLI_MSG_DELETING_PROJECT.format(project_name=project_name),
@@ -3470,7 +3565,26 @@ def delete_project(
                 )
             )
             _cleanup_project_embeddings(ingestor, project_name, projects)
-            ingestor.delete_project(project_name)
+            try:
+                ingestor.delete_project(project_name)
+            except Exception:
+                _sweep_glosses_after_failed_delete(ingestor, project_name)
+                raise
+            # A Gloss is out of the delete's reach by design, which is what
+            # lets it survive an index's delete-then-rebuild, so the
+            # deliberate delete sweeps the project's notes, as MCP
+            # `delete_project` does. Without it the next index re-attached
+            # them by name (issue #3231). The sweep never raises: the delete
+            # is done, and a retry would stop at "project not found".
+            if not prune_orphaned_glosses(ingestor, project_name):
+                app_context.console.print(
+                    style(
+                        cs.CLI_WARN_GLOSSES_NOT_PRUNED.format(
+                            project_name=project_name
+                        ),
+                        cs.Color.YELLOW,
+                    )
+                )
             _clear_deleted_project_markers(ingestor, project_name)
     except typer.Exit:
         raise

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/codebase_rag/cli_help.py

@@ -169,8 +169,10 @@ HELP_CHECK_BASE = (
 )
 HELP_CHECK_FAIL_ON_FOUND = (
     "Exit with status 1 when the delta reports dangling callers, dangling "
-    "importers, calls with too many arguments, new duplicates or new import "
-    "cycles. A possibly_missing site is reported but does not fail the check."
+    "importers, calls with too many arguments, too few for a required "
+    "parameter or a keyword the callee does not accept, new duplicates or new "
+    "import cycles. A possibly_missing site is reported but does not fail the "
+    "check."
 )
 HELP_CHECK_ISOLATED = (
     "Measure the edit, then put the graph and the hash cache back so the "

{code_graph_rag-0.2.0 → code_graph_rag-0.2.16}/codebase_rag/config.py

@@ -584,6 +584,10 @@ class AppConfig(BaseSettings):
 
     QUIET: bool = Field(False, validation_alias="CGR_QUIET")
 
+    # The GitHub Sponsors line a finished command ends on in a terminal; set
+    # false to drop it without the rest of the output `--quiet` drops.
+    SPONSOR_PLEDGE: bool = Field(True, validation_alias="CGR_SPONSOR_PLEDGE")
+
     # Compaction discards old tool output to bound the context (#1500). It is
     # on by default because an unbounded history eventually fails the request
     # outright, but a mechanism that drops data must be declinable: set this