rag-your-code 0.6.0__tar.gz → 0.8.0__tar.gz

{rag_your_code-0.6.0/src/rag_your_code.egg-info → rag_your_code-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rag-your-code
-Version: 0.6.0
+Version: 0.8.0
 Summary: A local, explainable RAG index for codebases and coding agents
 Author: rag-your-code contributors
 License-Expression: MIT
@@ -76,14 +76,23 @@ package itself on first use.
 ```bash
 pip install rag-your-code
 
-rag-your-code index .
+rag-your-code bootstrap .                  # index, and say what is still missing
 rag-your-code search "where are HTTP retries handled" --json
 rag-your-code search "what calls the retry handler" --graph --hops 1 --json
 ```
 
+`bootstrap` exists because indexing a repository is not the same as making it
+searchable, and nothing used to say so. A fresh index retrieves against the
+sentence the parser generated, which adds no word the source did not already
+have. It reports which rung this repository is on — descriptions still to
+write, a promotion to apply, or nothing left — and hands over that rung's
+work. It reads the state rather than remembering a position, so running it
+again after each round is how you make progress. `index` still exists and does
+only the indexing.
+
 The index is written under `.rag-your-code/`; your source files are never
-modified. Later `index` runs reuse unchanged files. For a large repository,
-prefer `rag-your-code index . --compact`.
+modified. Later runs reuse unchanged files. For a large repository, prefer
+`--compact`.
 
 ## How it works
 
@@ -135,16 +144,45 @@ A trained embedding model scores row 2 at around 0.8. Here a synonym pair and
 an unrelated pair are indistinguishable, because no shared word is no shared
 word either way.
 
-Retrieval works regardless, because **identifiers and docstrings are already
-natural language** — `retry_charge` contains *retry* and *charge*. But it
-reaches only concepts somebody wrote down. Two things close the rest of the
-gap, and neither is a model:
+Retrieval works regardless, because **the prose people write about code is
+already natural language** — docstrings, comments, descriptions. Identifiers
+are not part of that, and it is worth being exact: `retry_charge` tokenizes to
+one opaque term, not to *retry* and *charge*. Splitting identifiers was
+implemented and measured against all three rulers, with query and stored
+vectors rebuilt together, and it was equal or worse on every one; the pieces it
+makes are `get`, `find`, `check`, `test`, which rarity weighting immediately
+discounts to nothing.
+
+So retrieval reaches only concepts somebody wrote down. Two things close the
+rest of the gap, and neither is a model:
 
 - **Your agent rewrites the query.** It has the conversation; turning
   "重试扣款" into `retry charge payment gateway` costs it nothing.
 - **Your agent writes the descriptions**, which puts the missing vocabulary
   into the index once instead of into every query.
 
+### Seven attempts to make the vector half earn its place
+
+Because "just use a better embedding" is the obvious next thought, it was
+measured rather than argued about. Six schemes were implemented — character
+n-grams, corpus co-occurrence via random indexing, truncated SVD, posting-list
+signatures, a rarity- and field-weighted hash, and call-graph diffusion — plus
+lexical postings expansion and embedding only the authored text. **On the
+foreign-repository ruler, not one of them beat using no vector at all.**
+
+The reason is architectural, not representational. Retrieval scores only the
+units the lexical half already matched, so a vector can reorder an answer but
+can never make one *retrievable*; pure cosine fires only when nothing matched
+at all, on 1 question of 35. Every scheme was competing for the same one- or
+two-question reshuffle inside a list that had already been chosen.
+
+Two things follow, and both are stated here rather than buried. Corpus-learned
+semantics need orders of magnitude more text than a repository has: 65% of the
+foreign corpus's terms appear in four or fewer units, so their co-occurrence
+row is a handful of sightings rather than a distribution. And on a *described*
+repository the shipped hash is useful precisely because it is blunt — every
+scheme that sharpened it lost ground there.
+
 ## Agent-authored descriptions
 
 Every unit carries a description, and that description is indexed. By default
@@ -330,6 +368,7 @@ full rebuild. The rest take effect immediately and invalidate nothing.
 one reply per line:
 
 ```json
+{"action":"bootstrap"}
 {"action":"search","query":"database transaction rollback","limit":5}
 {"action":"research","query":"trace payment retry behavior","max_steps":2}
 {"action":"neighbors","id":"payments.py:4:retry_charge","hops":1}
@@ -340,6 +379,14 @@ one reply per line:
 {"action":"stats"}
 ```
 
+**A result is navigation, not the file.** `results` carries the identifier,
+path, line range, signature, description, score and matched terms. The code
+arrives once, in the reply's `context`, trimmed to `max_chars`, and
+`omitted_for_budget` says how many results it did not reach. Carrying the
+source per result as well is what let one `search --json` reply reach 65,025
+characters against a stated budget of 12,000, and one `research` reply reach
+111,843 by serialising the same eight units three times over.
+
 **No single request can end the session.** Numeric fields saturate at their
 bounds, `open` is bounded in both lines and bytes, and anything unanticipated
 is reported in-band with its exception type. Streams are pinned to UTF-8
@@ -360,14 +407,66 @@ it stopped.
 Nothing authored lives under `.rag-your-code/` — that directory is what people
 delete to clear the cache.
 
-## Not here yet
+## Bringing your own model
+
+Everything above works with no model at all. If you would rather have real
+semantics, point the index at any OpenAI-compatible embeddings endpoint —
+which includes a model server on your own machine:
+
+```toml
+# rag-your-code.toml
+[embedding]
+provider   = "openai-compatible"
+endpoint   = "http://localhost:11434/v1/embeddings"   # ollama, LM Studio, vLLM…
+model      = "nomic-embed-text"
+dimensions = 768                                      # must match the model
+```
+
+A hosted service is the same three lines with an `https://` endpoint, plus the
+name of the environment variable holding your key:
+
+```toml
+api_key_env = "OPENAI_API_KEY"    # the NAME of the variable, never the key
+```
 
-Provider-backed embeddings, Tree-sitter parsing, and a SQLite/ANN storage layer
-for repositories past the measured JSON envelope. Agent-authored descriptions
-are deliberately the cheaper answer to the same problem provider embeddings
-solve: they keep the zero-dependency, offline, reproducible-index properties,
-and produce text a human can read and correct rather than opaque floats. See
-[docs/ROADMAP.md](docs/ROADMAP.md).
+**The key is never a setting.** `rag-your-code.toml` is meant to be committed
+so everyone who clones can see what shaped the index; a credential is the one
+value with the opposite requirement, so the file only ever names the variable
+it lives in. Sending a key over plain `http://` to anything but your own
+machine is refused rather than warned about.
+
+Three things follow from turning this on, and it is worth knowing all three
+before you do:
+
+- **Your source leaves the machine**, unless the endpoint is local. That is
+  the whole reason the local case is written first here.
+- **Similarity may now find things, not just order them.** With the local
+  hash a cosine shortlist is measurably noise, so it is confined to
+  re-ranking. A real model earns the right to add candidates the words never
+  reached, which is the one gap no amount of ranking closes:
+  `search.vector_recall` sets how many. Lexical evidence still dominates — a
+  unit found by similarity alone scores at most `search.vector_weight`.
+- **A failure stops the build.** Falling back to the local hash would leave an
+  index whose vectors come from two incompatible spaces, and ranking would act
+  on the meaningless cosine between them with full confidence.
+
+Switching provider, model or width discards the old vectors and rebuilds, so
+an index can never be a mixture. An incremental run over unchanged files makes
+no request at all.
+
+**What is not measured:** whether this helps *your* repository, and by how
+much. No number here is from a real model — this project has no key, and a
+figure produced by a stub would be fiction. The instrument ships instead:
+point `benchmarks/repo_queries.py --index` at your own index and grade it. You
+will probably also want a higher `search.vector_weight` than the 0.15 tuned
+for a hash that carries no meaning.
+
+## Still not here
+
+Tree-sitter parsing, and a SQLite/ANN storage layer for repositories past the
+measured JSON envelope. Note also that `search.vector_recall` scans every
+unit's vector on every query, which is fine at the measured envelope and is
+the thing an ANN index would replace. See [docs/ROADMAP.md](docs/ROADMAP.md).
 
 ## Development
 

{rag_your_code-0.6.0 → rag_your_code-0.8.0}/README.md

@@ -49,14 +49,23 @@ package itself on first use.
 ```bash
 pip install rag-your-code
 
-rag-your-code index .
+rag-your-code bootstrap .                  # index, and say what is still missing
 rag-your-code search "where are HTTP retries handled" --json
 rag-your-code search "what calls the retry handler" --graph --hops 1 --json
 ```
 
+`bootstrap` exists because indexing a repository is not the same as making it
+searchable, and nothing used to say so. A fresh index retrieves against the
+sentence the parser generated, which adds no word the source did not already
+have. It reports which rung this repository is on — descriptions still to
+write, a promotion to apply, or nothing left — and hands over that rung's
+work. It reads the state rather than remembering a position, so running it
+again after each round is how you make progress. `index` still exists and does
+only the indexing.
+
 The index is written under `.rag-your-code/`; your source files are never
-modified. Later `index` runs reuse unchanged files. For a large repository,
-prefer `rag-your-code index . --compact`.
+modified. Later runs reuse unchanged files. For a large repository, prefer
+`--compact`.
 
 ## How it works
 
@@ -108,16 +117,45 @@ A trained embedding model scores row 2 at around 0.8. Here a synonym pair and
 an unrelated pair are indistinguishable, because no shared word is no shared
 word either way.
 
-Retrieval works regardless, because **identifiers and docstrings are already
-natural language** — `retry_charge` contains *retry* and *charge*. But it
-reaches only concepts somebody wrote down. Two things close the rest of the
-gap, and neither is a model:
+Retrieval works regardless, because **the prose people write about code is
+already natural language** — docstrings, comments, descriptions. Identifiers
+are not part of that, and it is worth being exact: `retry_charge` tokenizes to
+one opaque term, not to *retry* and *charge*. Splitting identifiers was
+implemented and measured against all three rulers, with query and stored
+vectors rebuilt together, and it was equal or worse on every one; the pieces it
+makes are `get`, `find`, `check`, `test`, which rarity weighting immediately
+discounts to nothing.
+
+So retrieval reaches only concepts somebody wrote down. Two things close the
+rest of the gap, and neither is a model:
 
 - **Your agent rewrites the query.** It has the conversation; turning
   "重试扣款" into `retry charge payment gateway` costs it nothing.
 - **Your agent writes the descriptions**, which puts the missing vocabulary
   into the index once instead of into every query.
 
+### Seven attempts to make the vector half earn its place
+
+Because "just use a better embedding" is the obvious next thought, it was
+measured rather than argued about. Six schemes were implemented — character
+n-grams, corpus co-occurrence via random indexing, truncated SVD, posting-list
+signatures, a rarity- and field-weighted hash, and call-graph diffusion — plus
+lexical postings expansion and embedding only the authored text. **On the
+foreign-repository ruler, not one of them beat using no vector at all.**
+
+The reason is architectural, not representational. Retrieval scores only the
+units the lexical half already matched, so a vector can reorder an answer but
+can never make one *retrievable*; pure cosine fires only when nothing matched
+at all, on 1 question of 35. Every scheme was competing for the same one- or
+two-question reshuffle inside a list that had already been chosen.
+
+Two things follow, and both are stated here rather than buried. Corpus-learned
+semantics need orders of magnitude more text than a repository has: 65% of the
+foreign corpus's terms appear in four or fewer units, so their co-occurrence
+row is a handful of sightings rather than a distribution. And on a *described*
+repository the shipped hash is useful precisely because it is blunt — every
+scheme that sharpened it lost ground there.
+
 ## Agent-authored descriptions
 
 Every unit carries a description, and that description is indexed. By default
@@ -303,6 +341,7 @@ full rebuild. The rest take effect immediately and invalidate nothing.
 one reply per line:
 
 ```json
+{"action":"bootstrap"}
 {"action":"search","query":"database transaction rollback","limit":5}
 {"action":"research","query":"trace payment retry behavior","max_steps":2}
 {"action":"neighbors","id":"payments.py:4:retry_charge","hops":1}
@@ -313,6 +352,14 @@ one reply per line:
 {"action":"stats"}
 ```
 
+**A result is navigation, not the file.** `results` carries the identifier,
+path, line range, signature, description, score and matched terms. The code
+arrives once, in the reply's `context`, trimmed to `max_chars`, and
+`omitted_for_budget` says how many results it did not reach. Carrying the
+source per result as well is what let one `search --json` reply reach 65,025
+characters against a stated budget of 12,000, and one `research` reply reach
+111,843 by serialising the same eight units three times over.
+
 **No single request can end the session.** Numeric fields saturate at their
 bounds, `open` is bounded in both lines and bytes, and anything unanticipated
 is reported in-band with its exception type. Streams are pinned to UTF-8
@@ -333,14 +380,66 @@ it stopped.
 Nothing authored lives under `.rag-your-code/` — that directory is what people
 delete to clear the cache.
 
-## Not here yet
+## Bringing your own model
+
+Everything above works with no model at all. If you would rather have real
+semantics, point the index at any OpenAI-compatible embeddings endpoint —
+which includes a model server on your own machine:
+
+```toml
+# rag-your-code.toml
+[embedding]
+provider   = "openai-compatible"
+endpoint   = "http://localhost:11434/v1/embeddings"   # ollama, LM Studio, vLLM…
+model      = "nomic-embed-text"
+dimensions = 768                                      # must match the model
+```
+
+A hosted service is the same three lines with an `https://` endpoint, plus the
+name of the environment variable holding your key:
+
+```toml
+api_key_env = "OPENAI_API_KEY"    # the NAME of the variable, never the key
+```
 
-Provider-backed embeddings, Tree-sitter parsing, and a SQLite/ANN storage layer
-for repositories past the measured JSON envelope. Agent-authored descriptions
-are deliberately the cheaper answer to the same problem provider embeddings
-solve: they keep the zero-dependency, offline, reproducible-index properties,
-and produce text a human can read and correct rather than opaque floats. See
-[docs/ROADMAP.md](docs/ROADMAP.md).
+**The key is never a setting.** `rag-your-code.toml` is meant to be committed
+so everyone who clones can see what shaped the index; a credential is the one
+value with the opposite requirement, so the file only ever names the variable
+it lives in. Sending a key over plain `http://` to anything but your own
+machine is refused rather than warned about.
+
+Three things follow from turning this on, and it is worth knowing all three
+before you do:
+
+- **Your source leaves the machine**, unless the endpoint is local. That is
+  the whole reason the local case is written first here.
+- **Similarity may now find things, not just order them.** With the local
+  hash a cosine shortlist is measurably noise, so it is confined to
+  re-ranking. A real model earns the right to add candidates the words never
+  reached, which is the one gap no amount of ranking closes:
+  `search.vector_recall` sets how many. Lexical evidence still dominates — a
+  unit found by similarity alone scores at most `search.vector_weight`.
+- **A failure stops the build.** Falling back to the local hash would leave an
+  index whose vectors come from two incompatible spaces, and ranking would act
+  on the meaningless cosine between them with full confidence.
+
+Switching provider, model or width discards the old vectors and rebuilds, so
+an index can never be a mixture. An incremental run over unchanged files makes
+no request at all.
+
+**What is not measured:** whether this helps *your* repository, and by how
+much. No number here is from a real model — this project has no key, and a
+figure produced by a stub would be fiction. The instrument ships instead:
+point `benchmarks/repo_queries.py --index` at your own index and grade it. You
+will probably also want a higher `search.vector_weight` than the 0.15 tuned
+for a hash that carries no meaning.
+
+## Still not here
+
+Tree-sitter parsing, and a SQLite/ANN storage layer for repositories past the
+measured JSON envelope. Note also that `search.vector_recall` scans every
+unit's vector on every query, which is fine at the measured envelope and is
+the thing an ANN index would replace. See [docs/ROADMAP.md](docs/ROADMAP.md).
 
 ## Development
 

{rag_your_code-0.6.0 → rag_your_code-0.8.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rag-your-code"
-version = "0.6.0"
+version = "0.8.0"
 description = "A local, explainable RAG index for codebases and coding agents"
 readme = "README.md"
 requires-python = ">=3.10"

{rag_your_code-0.6.0 → rag_your_code-0.8.0/src/rag_your_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rag-your-code
-Version: 0.6.0
+Version: 0.8.0
 Summary: A local, explainable RAG index for codebases and coding agents
 Author: rag-your-code contributors
 License-Expression: MIT
@@ -76,14 +76,23 @@ package itself on first use.
 ```bash
 pip install rag-your-code
 
-rag-your-code index .
+rag-your-code bootstrap .                  # index, and say what is still missing
 rag-your-code search "where are HTTP retries handled" --json
 rag-your-code search "what calls the retry handler" --graph --hops 1 --json
 ```
 
+`bootstrap` exists because indexing a repository is not the same as making it
+searchable, and nothing used to say so. A fresh index retrieves against the
+sentence the parser generated, which adds no word the source did not already
+have. It reports which rung this repository is on — descriptions still to
+write, a promotion to apply, or nothing left — and hands over that rung's
+work. It reads the state rather than remembering a position, so running it
+again after each round is how you make progress. `index` still exists and does
+only the indexing.
+
 The index is written under `.rag-your-code/`; your source files are never
-modified. Later `index` runs reuse unchanged files. For a large repository,
-prefer `rag-your-code index . --compact`.
+modified. Later runs reuse unchanged files. For a large repository, prefer
+`--compact`.
 
 ## How it works
 
@@ -135,16 +144,45 @@ A trained embedding model scores row 2 at around 0.8. Here a synonym pair and
 an unrelated pair are indistinguishable, because no shared word is no shared
 word either way.
 
-Retrieval works regardless, because **identifiers and docstrings are already
-natural language** — `retry_charge` contains *retry* and *charge*. But it
-reaches only concepts somebody wrote down. Two things close the rest of the
-gap, and neither is a model:
+Retrieval works regardless, because **the prose people write about code is
+already natural language** — docstrings, comments, descriptions. Identifiers
+are not part of that, and it is worth being exact: `retry_charge` tokenizes to
+one opaque term, not to *retry* and *charge*. Splitting identifiers was
+implemented and measured against all three rulers, with query and stored
+vectors rebuilt together, and it was equal or worse on every one; the pieces it
+makes are `get`, `find`, `check`, `test`, which rarity weighting immediately
+discounts to nothing.
+
+So retrieval reaches only concepts somebody wrote down. Two things close the
+rest of the gap, and neither is a model:
 
 - **Your agent rewrites the query.** It has the conversation; turning
   "重试扣款" into `retry charge payment gateway` costs it nothing.
 - **Your agent writes the descriptions**, which puts the missing vocabulary
   into the index once instead of into every query.
 
+### Seven attempts to make the vector half earn its place
+
+Because "just use a better embedding" is the obvious next thought, it was
+measured rather than argued about. Six schemes were implemented — character
+n-grams, corpus co-occurrence via random indexing, truncated SVD, posting-list
+signatures, a rarity- and field-weighted hash, and call-graph diffusion — plus
+lexical postings expansion and embedding only the authored text. **On the
+foreign-repository ruler, not one of them beat using no vector at all.**
+
+The reason is architectural, not representational. Retrieval scores only the
+units the lexical half already matched, so a vector can reorder an answer but
+can never make one *retrievable*; pure cosine fires only when nothing matched
+at all, on 1 question of 35. Every scheme was competing for the same one- or
+two-question reshuffle inside a list that had already been chosen.
+
+Two things follow, and both are stated here rather than buried. Corpus-learned
+semantics need orders of magnitude more text than a repository has: 65% of the
+foreign corpus's terms appear in four or fewer units, so their co-occurrence
+row is a handful of sightings rather than a distribution. And on a *described*
+repository the shipped hash is useful precisely because it is blunt — every
+scheme that sharpened it lost ground there.
+
 ## Agent-authored descriptions
 
 Every unit carries a description, and that description is indexed. By default
@@ -330,6 +368,7 @@ full rebuild. The rest take effect immediately and invalidate nothing.
 one reply per line:
 
 ```json
+{"action":"bootstrap"}
 {"action":"search","query":"database transaction rollback","limit":5}
 {"action":"research","query":"trace payment retry behavior","max_steps":2}
 {"action":"neighbors","id":"payments.py:4:retry_charge","hops":1}
@@ -340,6 +379,14 @@ one reply per line:
 {"action":"stats"}
 ```
 
+**A result is navigation, not the file.** `results` carries the identifier,
+path, line range, signature, description, score and matched terms. The code
+arrives once, in the reply's `context`, trimmed to `max_chars`, and
+`omitted_for_budget` says how many results it did not reach. Carrying the
+source per result as well is what let one `search --json` reply reach 65,025
+characters against a stated budget of 12,000, and one `research` reply reach
+111,843 by serialising the same eight units three times over.
+
 **No single request can end the session.** Numeric fields saturate at their
 bounds, `open` is bounded in both lines and bytes, and anything unanticipated
 is reported in-band with its exception type. Streams are pinned to UTF-8
@@ -360,14 +407,66 @@ it stopped.
 Nothing authored lives under `.rag-your-code/` — that directory is what people
 delete to clear the cache.
 
-## Not here yet
+## Bringing your own model
+
+Everything above works with no model at all. If you would rather have real
+semantics, point the index at any OpenAI-compatible embeddings endpoint —
+which includes a model server on your own machine:
+
+```toml
+# rag-your-code.toml
+[embedding]
+provider   = "openai-compatible"
+endpoint   = "http://localhost:11434/v1/embeddings"   # ollama, LM Studio, vLLM…
+model      = "nomic-embed-text"
+dimensions = 768                                      # must match the model
+```
+
+A hosted service is the same three lines with an `https://` endpoint, plus the
+name of the environment variable holding your key:
+
+```toml
+api_key_env = "OPENAI_API_KEY"    # the NAME of the variable, never the key
+```
 
-Provider-backed embeddings, Tree-sitter parsing, and a SQLite/ANN storage layer
-for repositories past the measured JSON envelope. Agent-authored descriptions
-are deliberately the cheaper answer to the same problem provider embeddings
-solve: they keep the zero-dependency, offline, reproducible-index properties,
-and produce text a human can read and correct rather than opaque floats. See
-[docs/ROADMAP.md](docs/ROADMAP.md).
+**The key is never a setting.** `rag-your-code.toml` is meant to be committed
+so everyone who clones can see what shaped the index; a credential is the one
+value with the opposite requirement, so the file only ever names the variable
+it lives in. Sending a key over plain `http://` to anything but your own
+machine is refused rather than warned about.
+
+Three things follow from turning this on, and it is worth knowing all three
+before you do:
+
+- **Your source leaves the machine**, unless the endpoint is local. That is
+  the whole reason the local case is written first here.
+- **Similarity may now find things, not just order them.** With the local
+  hash a cosine shortlist is measurably noise, so it is confined to
+  re-ranking. A real model earns the right to add candidates the words never
+  reached, which is the one gap no amount of ranking closes:
+  `search.vector_recall` sets how many. Lexical evidence still dominates — a
+  unit found by similarity alone scores at most `search.vector_weight`.
+- **A failure stops the build.** Falling back to the local hash would leave an
+  index whose vectors come from two incompatible spaces, and ranking would act
+  on the meaningless cosine between them with full confidence.
+
+Switching provider, model or width discards the old vectors and rebuilds, so
+an index can never be a mixture. An incremental run over unchanged files makes
+no request at all.
+
+**What is not measured:** whether this helps *your* repository, and by how
+much. No number here is from a real model — this project has no key, and a
+figure produced by a stub would be fiction. The instrument ships instead:
+point `benchmarks/repo_queries.py --index` at your own index and grade it. You
+will probably also want a higher `search.vector_weight` than the 0.15 tuned
+for a hash that carries no meaning.
+
+## Still not here
+
+Tree-sitter parsing, and a SQLite/ANN storage layer for repositories past the
+measured JSON envelope. Note also that `search.vector_recall` scans every
+unit's vector on every query, which is fine at the measured envelope and is
+the thing an ANN index would replace. See [docs/ROADMAP.md](docs/ROADMAP.md).
 
 ## Development
 

{rag_your_code-0.6.0 → rag_your_code-0.8.0}/src/rag_your_code.egg-info/SOURCES.txt

@@ -19,8 +19,10 @@ src/ragyourcode/graph.py
 src/ragyourcode/indexer.py
 src/ragyourcode/models.py
 src/ragyourcode/parser.py
+src/ragyourcode/providers.py
 src/ragyourcode/py.typed
 src/ragyourcode/search.py
+src/ragyourcode/workflow.py
 tests/test_agent_protocol.py
 tests/test_agentic.py
 tests/test_config.py
@@ -35,8 +37,10 @@ tests/test_large_repo.py
 tests/test_metadata.py
 tests/test_multilanguage.py
 tests/test_parser_edges.py
+tests/test_providers.py
 tests/test_ragyourcode.py
 tests/test_ranking.py
 tests/test_repo_queries.py
 tests/test_resilience.py
-tests/test_retrieval_correctness.py
+tests/test_retrieval_correctness.py
+tests/test_workflow.py

{rag_your_code-0.6.0 → rag_your_code-0.8.0}/src/ragyourcode/__init__.py

@@ -3,4 +3,4 @@
 from .models import CodeUnit, SearchResult
 
 __all__ = ["CodeUnit", "SearchResult"]
-__version__ = "0.6.0"
+__version__ = "0.8.0"